Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

22 files changed, 48084 insertions, 0 deletions

diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_egl.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_egl.cpp
new file mode 100644
index 0000000000..ba0ab78e33
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_egl.cpp
@@ -0,0 +1,1096 @@
+//
+// Copyright(c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// entry_points_egl.cpp : Implements the EGL entry points.
+
+#include "libGLESv2/entry_points_egl.h"
+
+#include "common/debug.h"
+#include "common/utilities.h"
+#include "common/version.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/Display.h"
+#include "libANGLE/EGLSync.h"
+#include "libANGLE/Surface.h"
+#include "libANGLE/Texture.h"
+#include "libANGLE/Thread.h"
+#include "libANGLE/queryutils.h"
+#include "libANGLE/validationEGL.h"
+#include "libGLESv2/global_state.h"
+#include "libGLESv2/proc_table_egl.h"
+
+using namespace egl;
+
+namespace
+{
+
+bool CompareProc(const ProcEntry &a, const char *b)
+{
+    return strcmp(a.first, b) < 0;
+}
+
+void ClipConfigs(const std::vector<const Config *> &filteredConfigs,
+                 EGLConfig *output_configs,
+                 EGLint config_size,
+                 EGLint *num_config)
+{
+    EGLint result_size = static_cast<EGLint>(filteredConfigs.size());
+    if (output_configs)
+    {
+        result_size = std::max(std::min(result_size, config_size), 0);
+        for (EGLint i = 0; i < result_size; i++)
+        {
+            output_configs[i] = const_cast<Config *>(filteredConfigs[i]);
+        }
+    }
+    *num_config = result_size;
+}
+}  // anonymous namespace
+
+extern "C" {
+// EGL 1.0
+EGLint EGLAPIENTRY EGL_GetError(void)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("()");
+    Thread *thread = egl::GetCurrentThread();
+
+    EGLint error = thread->getError();
+    thread->setSuccess();
+    return error;
+}
+
+EGLDisplay EGLAPIENTRY EGL_GetDisplay(EGLNativeDisplayType display_id)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLNativeDisplayType display_id = 0x%016" PRIxPTR ")", (uintptr_t)display_id);
+
+    return egl::Display::GetDisplayFromNativeDisplay(display_id, AttributeMap());
+}
+
+EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint *major = 0x%016" PRIxPTR
+          ", EGLint *minor = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)major, (uintptr_t)minor);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    ANGLE_EGL_TRY_RETURN(thread, ValidateInitialize(display), "eglInitialize",
+                         GetDisplayIfValid(display), EGL_FALSE);
+
+    ANGLE_EGL_TRY_RETURN(thread, display->initialize(), "eglInitialize", GetDisplayIfValid(display),
+                         EGL_FALSE);
+
+    if (major)
+        *major = 1;
+    if (minor)
+        *minor = 4;
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ")", (uintptr_t)dpy);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    ANGLE_EGL_TRY_RETURN(thread, ValidateTerminate(display), "eglTerminate",
+                         GetDisplayIfValid(display), EGL_FALSE);
+
+    ANGLE_EGL_TRY_RETURN(thread, display->makeCurrent(thread, nullptr, nullptr, nullptr),
+                         "eglTerminate", GetDisplayIfValid(display), EGL_FALSE);
+    SetContextCurrent(thread, nullptr);
+    ANGLE_EGL_TRY_RETURN(thread, display->terminate(thread), "eglTerminate",
+                         GetDisplayIfValid(display), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint name = %d)", (uintptr_t)dpy, name);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    if (!(display == EGL_NO_DISPLAY && name == EGL_EXTENSIONS))
+    {
+        ANGLE_EGL_TRY_RETURN(thread, ValidateDisplay(display), "eglQueryString",
+                             GetDisplayIfValid(display), nullptr);
+    }
+
+    const char *result;
+    switch (name)
+    {
+        case EGL_CLIENT_APIS:
+            result = "OpenGL_ES";
+            break;
+        case EGL_EXTENSIONS:
+            if (display == EGL_NO_DISPLAY)
+            {
+                result = egl::Display::GetClientExtensionString().c_str();
+            }
+            else
+            {
+                result = display->getExtensionString().c_str();
+            }
+            break;
+        case EGL_VENDOR:
+            result = display->getVendorString().c_str();
+            break;
+        case EGL_VERSION:
+            result = "1.4 (ANGLE " ANGLE_VERSION_STRING ")";
+            break;
+        default:
+            thread->setError(EglBadParameter(), GetDebug(), "eglQueryString",
+                             GetDisplayIfValid(display));
+            return nullptr;
+    }
+
+    thread->setSuccess();
+    return result;
+}
+
+EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy,
+                                      EGLConfig *configs,
+                                      EGLint config_size,
+                                      EGLint *num_config)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig *configs = 0x%016" PRIxPTR
+          ", "
+          "EGLint config_size = %d, EGLint *num_config = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)configs, config_size, (uintptr_t)num_config);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateGetConfigs(display, config_size, num_config),
+                         "eglGetConfigs", GetDisplayIfValid(display), EGL_FALSE);
+
+    ClipConfigs(display->getConfigs(AttributeMap()), configs, config_size, num_config);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy,
+                                        const EGLint *attrib_list,
+                                        EGLConfig *configs,
+                                        EGLint config_size,
+                                        EGLint *num_config)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", const EGLint *attrib_list = 0x%016" PRIxPTR
+          ", "
+          "EGLConfig *configs = 0x%016" PRIxPTR
+          ", EGLint config_size = %d, EGLint *num_config = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)attrib_list, (uintptr_t)configs, config_size,
+          (uintptr_t)num_config);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display  = static_cast<egl::Display *>(dpy);
+    AttributeMap attribMap = AttributeMap::CreateFromIntArray(attrib_list);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateChooseConfig(display, attribMap, config_size, num_config),
+                         "eglChooseConfig", GetDisplayIfValid(display), EGL_FALSE);
+
+    ClipConfigs(display->chooseConfig(attribMap), configs, config_size, num_config);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy,
+                                           EGLConfig config,
+                                           EGLint attribute,
+                                           EGLint *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", EGLint attribute = %d, EGLint "
+          "*value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, attribute, (uintptr_t)value);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Config *configuration = static_cast<Config *>(config);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateGetConfigAttrib(display, configuration, attribute),
+                         "eglGetConfigAttrib", GetDisplayIfValid(display), EGL_FALSE);
+
+    QueryConfigAttrib(configuration, attribute, value);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy,
+                                               EGLConfig config,
+                                               EGLNativeWindowType win,
+                                               const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", EGLNativeWindowType win = 0x%016" PRIxPTR
+          ", "
+          "const EGLint *attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)win, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    Config *configuration   = static_cast<Config *>(config);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
+
+    ANGLE_EGL_TRY_RETURN(thread,
+                         ValidateCreateWindowSurface(display, configuration, win, attributes),
+                         "eglCreateWindowSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    egl::Surface *surface = nullptr;
+    ANGLE_EGL_TRY_RETURN(thread,
+                         display->createWindowSurface(configuration, win, attributes, &surface),
+                         "eglCreateWindowSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    return static_cast<EGLSurface>(surface);
+}
+
+EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy,
+                                                EGLConfig config,
+                                                const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", const EGLint *attrib_list = "
+          "0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    Config *configuration   = static_cast<Config *>(config);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateCreatePbufferSurface(display, configuration, attributes),
+                         "eglCreatePbufferSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    egl::Surface *surface = nullptr;
+    ANGLE_EGL_TRY_RETURN(thread, display->createPbufferSurface(configuration, attributes, &surface),
+                         "eglCreatePbufferSurface", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    return static_cast<EGLSurface>(surface);
+}
+
+EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy,
+                                               EGLConfig config,
+                                               EGLNativePixmapType pixmap,
+                                               const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", EGLNativePixmapType pixmap = "
+          "0x%016" PRIxPTR
+          ", "
+          "const EGLint *attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)pixmap, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Config *configuration = static_cast<Config *>(config);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateConfig(display, configuration), "eglCreatePixmapSurface",
+                         GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    UNIMPLEMENTED();  // FIXME
+
+    thread->setSuccess();
+    return EGL_NO_SURFACE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)surface);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateDestroySurface(display, eglSurface, surface),
+                         "eglDestroySurface", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    ANGLE_EGL_TRY_RETURN(thread, display->destroySurface(eglSurface), "eglDestroySurface",
+                         GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy,
+                                        EGLSurface surface,
+                                        EGLint attribute,
+                                        EGLint *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint attribute = %d, EGLint "
+          "*value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)surface, attribute, (uintptr_t)value);
+    Thread *thread = egl::GetCurrentThread();
+
+    const egl::Display *display = static_cast<const egl::Display *>(dpy);
+    const Surface *eglSurface   = static_cast<const Surface *>(surface);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateQuerySurface(display, eglSurface, attribute, value),
+                         "eglQuerySurface", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    QuerySurfaceAttrib(eglSurface, attribute, value);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy,
+                                         EGLConfig config,
+                                         EGLContext share_context,
+                                         const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", EGLContext share_context = "
+          "0x%016" PRIxPTR
+          ", "
+          "const EGLint *attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)share_context, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display        = static_cast<egl::Display *>(dpy);
+    Config *configuration        = static_cast<Config *>(config);
+    gl::Context *sharedGLContext = static_cast<gl::Context *>(share_context);
+    AttributeMap attributes      = AttributeMap::CreateFromIntArray(attrib_list);
+
+    ANGLE_EGL_TRY_RETURN(thread,
+                         ValidateCreateContext(display, configuration, sharedGLContext, attributes),
+                         "eglCreateContext", GetDisplayIfValid(display), EGL_NO_CONTEXT);
+
+    gl::Context *context = nullptr;
+    ANGLE_EGL_TRY_RETURN(thread,
+                         display->createContext(configuration, sharedGLContext, thread->getAPI(),
+                                                attributes, &context),
+                         "eglCreateContext", GetDisplayIfValid(display), EGL_NO_CONTEXT);
+
+    thread->setSuccess();
+    return static_cast<EGLContext>(context);
+}
+
+EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLContext ctx = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)ctx);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    gl::Context *context  = static_cast<gl::Context *>(ctx);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateDestroyContext(display, context, ctx), "eglDestroyContext",
+                         GetContextIfValid(display, context), EGL_FALSE);
+
+    bool contextWasCurrent = context == thread->getContext();
+
+    ANGLE_EGL_TRY_RETURN(thread, display->destroyContext(thread, context), "eglDestroyContext",
+                         GetContextIfValid(display, context), EGL_FALSE);
+
+    if (contextWasCurrent)
+    {
+        SetContextCurrent(thread, nullptr);
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy,
+                                       EGLSurface draw,
+                                       EGLSurface read,
+                                       EGLContext ctx)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface draw = 0x%016" PRIxPTR
+          ", EGLSurface read = 0x%016" PRIxPTR
+          ", "
+          "EGLContext ctx = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)draw, (uintptr_t)read, (uintptr_t)ctx);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *drawSurface  = static_cast<Surface *>(draw);
+    Surface *readSurface  = static_cast<Surface *>(read);
+    gl::Context *context  = static_cast<gl::Context *>(ctx);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateMakeCurrent(display, drawSurface, readSurface, context),
+                         "eglMakeCurrent", GetContextIfValid(display, context), EGL_FALSE);
+
+    Surface *previousDraw        = thread->getCurrentDrawSurface();
+    Surface *previousRead        = thread->getCurrentReadSurface();
+    gl::Context *previousContext = thread->getContext();
+
+    // Only call makeCurrent if the context or surfaces have changed.
+    if (previousDraw != drawSurface || previousRead != readSurface || previousContext != context)
+    {
+        ANGLE_EGL_TRY_RETURN(thread,
+                             display->makeCurrent(thread, drawSurface, readSurface, context),
+                             "eglMakeCurrent", GetContextIfValid(display, context), EGL_FALSE);
+
+        SetContextCurrent(thread, context);
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLSurface EGLAPIENTRY EGL_GetCurrentSurface(EGLint readdraw)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLint readdraw = %d)", readdraw);
+    Thread *thread = egl::GetCurrentThread();
+
+    if (readdraw == EGL_READ)
+    {
+        thread->setSuccess();
+        return thread->getCurrentReadSurface();
+    }
+    else if (readdraw == EGL_DRAW)
+    {
+        thread->setSuccess();
+        return thread->getCurrentDrawSurface();
+    }
+    else
+    {
+        thread->setError(EglBadParameter(), GetDebug(), "eglGetCurrentSurface", nullptr);
+        return EGL_NO_SURFACE;
+    }
+}
+
+EGLDisplay EGLAPIENTRY EGL_GetCurrentDisplay(void)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("()");
+    Thread *thread = egl::GetCurrentThread();
+
+    thread->setSuccess();
+    if (thread->getContext() != nullptr)
+    {
+        return thread->getContext()->getDisplay();
+    }
+    return EGL_NO_DISPLAY;
+}
+
+EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy,
+                                        EGLContext ctx,
+                                        EGLint attribute,
+                                        EGLint *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLContext ctx = 0x%016" PRIxPTR
+          ", EGLint attribute = %d, EGLint *value "
+          "= 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)ctx, attribute, (uintptr_t)value);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    gl::Context *context  = static_cast<gl::Context *>(ctx);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateQueryContext(display, context, attribute, value),
+                         "eglQueryContext", GetContextIfValid(display, context), EGL_FALSE);
+
+    QueryContextAttrib(context, attribute, value);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_WaitGL(void)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("()");
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = thread->getDisplay();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateDisplay(display), "eglWaitGL", GetDisplayIfValid(display),
+                         EGL_FALSE);
+
+    // eglWaitGL like calling eglWaitClient with the OpenGL ES API bound. Since we only implement
+    // OpenGL ES we can do the call directly.
+    ANGLE_EGL_TRY_RETURN(thread, display->waitClient(thread->getContext()), "eglWaitGL",
+                         GetDisplayIfValid(display), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLint engine = %d)", engine);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = thread->getDisplay();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateWaitNative(display, engine), "eglWaitNative",
+                         GetThreadIfValid(thread), EGL_FALSE);
+
+    ANGLE_EGL_TRY_RETURN(thread, display->waitNative(thread->getContext(), engine), "eglWaitNative",
+                         GetThreadIfValid(thread), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)surface);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = (Surface *)surface;
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateSwapBuffers(thread, display, eglSurface), "eglSwapBuffers",
+                         GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    ANGLE_EGL_TRY_RETURN(thread, eglSurface->swap(thread->getContext()), "eglSwapBuffers",
+                         GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy,
+                                       EGLSurface surface,
+                                       EGLNativePixmapType target)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLNativePixmapType target = "
+          "0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)target);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateCopyBuffers(display, eglSurface), "eglCopyBuffers",
+                         GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    UNIMPLEMENTED();  // FIXME
+
+    thread->setSuccess();
+    return 0;
+}
+
+// EGL 1.1
+EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint buffer = %d)",
+          (uintptr_t)dpy, (uintptr_t)surface, buffer);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display      = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface        = static_cast<Surface *>(surface);
+    gl::Context *context       = thread->getContext();
+    gl::Texture *textureObject = nullptr;
+
+    ANGLE_EGL_TRY_RETURN(
+        thread, ValidateBindTexImage(display, eglSurface, surface, buffer, context, &textureObject),
+        "eglBindTexImage", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    if (context)
+    {
+        ANGLE_EGL_TRY_RETURN(thread, eglSurface->bindTexImage(context, textureObject, buffer),
+                             "eglBindTexImage", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy,
+                                         EGLSurface surface,
+                                         EGLint attribute,
+                                         EGLint value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint attribute = %d, EGLint "
+          "value = %d)",
+          (uintptr_t)dpy, (uintptr_t)surface, attribute, value);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateSurfaceAttrib(display, eglSurface, attribute, value),
+                         "eglSurfaceAttrib", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    SetSurfaceAttrib(eglSurface, attribute, value);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint buffer = %d)",
+          (uintptr_t)dpy, (uintptr_t)surface, buffer);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateReleaseTexImage(display, eglSurface, surface, buffer),
+                         "eglReleaseTexImage", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    gl::Texture *texture = eglSurface->getBoundTexture();
+
+    if (texture)
+    {
+        ANGLE_EGL_TRY_RETURN(thread, eglSurface->releaseTexImage(thread->getContext(), buffer),
+                             "eglReleaseTexImage", GetSurfaceIfValid(display, eglSurface),
+                             EGL_FALSE);
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint interval = %d)", (uintptr_t)dpy, interval);
+    Thread *thread       = egl::GetCurrentThread();
+    gl::Context *context = thread->getContext();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *draw_surface = static_cast<Surface *>(thread->getCurrentDrawSurface());
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateSwapInterval(display, draw_surface, context),
+                         "eglSwapInterval", GetDisplayIfValid(display), EGL_FALSE);
+
+    const egl::Config *surfaceConfig = draw_surface->getConfig();
+    EGLint clampedInterval           = std::min(std::max(interval, surfaceConfig->minSwapInterval),
+                                      surfaceConfig->maxSwapInterval);
+
+    draw_surface->setSwapInterval(clampedInterval);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL 1.2
+EGLBoolean EGLAPIENTRY EGL_BindAPI(EGLenum api)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLenum api = 0x%X)", api);
+    Thread *thread = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateBindAPI(api), "eglBindAPI", GetThreadIfValid(thread),
+                         EGL_FALSE);
+
+    thread->setAPI(api);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLenum EGLAPIENTRY EGL_QueryAPI(void)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("()");
+    Thread *thread = egl::GetCurrentThread();
+
+    EGLenum API = thread->getAPI();
+
+    thread->setSuccess();
+    return API;
+}
+
+EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy,
+                                                         EGLenum buftype,
+                                                         EGLClientBuffer buffer,
+                                                         EGLConfig config,
+                                                         const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR
+          ", EGLenum buftype = 0x%X, EGLClientBuffer buffer = 0x%016" PRIxPTR
+          ", "
+          "EGLConfig config = 0x%016" PRIxPTR ", const EGLint *attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, buftype, (uintptr_t)buffer, (uintptr_t)config, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    Config *configuration   = static_cast<Config *>(config);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
+
+    ANGLE_EGL_TRY_RETURN(
+        thread,
+        ValidateCreatePbufferFromClientBuffer(display, buftype, buffer, configuration, attributes),
+        "eglCreatePbufferFromClientBuffer", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    egl::Surface *surface = nullptr;
+    ANGLE_EGL_TRY_RETURN(thread,
+                         display->createPbufferFromClientBuffer(configuration, buftype, buffer,
+                                                                attributes, &surface),
+                         "eglCreatePbufferFromClientBuffer", GetDisplayIfValid(display),
+                         EGL_NO_SURFACE);
+
+    return static_cast<EGLSurface>(surface);
+}
+
+EGLBoolean EGLAPIENTRY EGL_ReleaseThread(void)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("()");
+    Thread *thread = egl::GetCurrentThread();
+
+    Surface *previousDraw         = thread->getCurrentDrawSurface();
+    Surface *previousRead         = thread->getCurrentReadSurface();
+    gl::Context *previousContext  = thread->getContext();
+    egl::Display *previousDisplay = thread->getDisplay();
+
+    // Only call makeCurrent if the context or surfaces have changed.
+    if (previousDraw != EGL_NO_SURFACE || previousRead != EGL_NO_SURFACE ||
+        previousContext != EGL_NO_CONTEXT)
+    {
+        if (previousDisplay != EGL_NO_DISPLAY)
+        {
+            ANGLE_EGL_TRY_RETURN(thread,
+                                 previousDisplay->makeCurrent(thread, nullptr, nullptr, nullptr),
+                                 "eglReleaseThread", nullptr, EGL_FALSE);
+        }
+
+        SetContextCurrent(thread, nullptr);
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_WaitClient(void)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("()");
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = thread->getDisplay();
+    gl::Context *context  = thread->getContext();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateDisplay(display), "eglWaitClient",
+                         GetContextIfValid(display, context), EGL_FALSE);
+
+    ANGLE_EGL_TRY_RETURN(thread, display->waitClient(context), "eglWaitClient",
+                         GetContextIfValid(display, context), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL 1.4
+EGLContext EGLAPIENTRY EGL_GetCurrentContext(void)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("()");
+    Thread *thread = egl::GetCurrentThread();
+
+    gl::Context *context = thread->getContext();
+
+    thread->setSuccess();
+    return static_cast<EGLContext>(context);
+}
+
+// EGL 1.5
+EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR
+          ", EGLenum type = 0x%X, const EGLint* attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, type, (uintptr_t)attrib_list);
+
+    Thread *thread          = egl::GetCurrentThread();
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
+
+    gl::Context *currentContext  = thread->getContext();
+    egl::Display *currentDisplay = currentContext ? currentContext->getDisplay() : nullptr;
+
+    ANGLE_EGL_TRY_RETURN(
+        thread, ValidateCreateSyncKHR(display, type, attributes, currentDisplay, currentContext),
+        "eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
+
+    egl::Sync *syncObject = nullptr;
+    ANGLE_EGL_TRY_RETURN(thread, display->createSync(currentContext, type, attributes, &syncObject),
+                         "eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
+
+    thread->setSuccess();
+    return static_cast<EGLSync>(syncObject);
+}
+
+EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR ")", (uintptr_t)dpy,
+          (uintptr_t)sync);
+
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    egl::Sync *syncObject = static_cast<Sync *>(sync);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateDestroySync(display, syncObject), "eglDestroySync",
+                         GetDisplayIfValid(display), EGL_FALSE);
+
+    display->destroySync(syncObject);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR
+          ", EGLint flags = 0x%X, EGLTime timeout = "
+          "%llu)",
+          (uintptr_t)dpy, (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout));
+
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    egl::Sync *syncObject = static_cast<Sync *>(sync);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateClientWaitSync(display, syncObject, flags, timeout),
+                         "eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    gl::Context *currentContext = thread->getContext();
+    EGLint syncStatus           = EGL_FALSE;
+    ANGLE_EGL_TRY_RETURN(
+        thread, syncObject->clientWait(display, currentContext, flags, timeout, &syncStatus),
+        "eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    thread->setSuccess();
+    return syncStatus;
+}
+
+EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy,
+                                         EGLSync sync,
+                                         EGLint attribute,
+                                         EGLAttrib *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR
+          ", EGLint attribute = 0x%X, EGLAttrib "
+          "*value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)sync, attribute, (uintptr_t)value);
+
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    egl::Sync *syncObject = static_cast<Sync *>(sync);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateGetSyncAttrib(display, syncObject, attribute, value),
+                         "eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    EGLint valueExt;
+    ANGLE_EGL_TRY_RETURN(thread, GetSyncAttrib(display, syncObject, attribute, &valueExt),
+                         "eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE);
+    *value = valueExt;
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy,
+                                     EGLContext ctx,
+                                     EGLenum target,
+                                     EGLClientBuffer buffer,
+                                     const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLContext ctx = 0x%016" PRIxPTR
+          ", EGLenum target = 0x%X, "
+          "EGLClientBuffer buffer = 0x%016" PRIxPTR
+          ", const EGLAttrib *attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)ctx, target, (uintptr_t)buffer, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    gl::Context *context    = static_cast<gl::Context *>(ctx);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray((const EGLint *)attrib_list);
+
+    Error error = ValidateCreateImage(display, context, target, buffer, attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateImage", GetDisplayIfValid(display));
+        return EGL_NO_IMAGE;
+    }
+
+    Image *image = nullptr;
+    error        = display->createImage(context, target, buffer, attributes, &image);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateImage", GetDisplayIfValid(display));
+        return EGL_NO_IMAGE;
+    }
+
+    thread->setSuccess();
+    return static_cast<EGLImage>(image);
+}
+
+EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLImage image = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)image);
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Image *img            = static_cast<Image *>(image);
+
+    Error error = ValidateDestroyImage(display, img);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglDestroyImage", GetImageIfValid(display, img));
+        return EGL_FALSE;
+    }
+
+    display->destroyImage(img);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform,
+                                              void *native_display,
+                                              const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLenum platform = %d, void* native_display = 0x%016" PRIxPTR
+          ", const EGLint* attrib_list = "
+          "0x%016" PRIxPTR ")",
+          platform, (uintptr_t)native_display, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateGetPlatformDisplay(platform, native_display, attrib_list),
+                         "eglGetPlatformDisplay", GetThreadIfValid(thread), EGL_NO_DISPLAY);
+
+    const auto &attribMap = AttributeMap::CreateFromAttribArray(attrib_list);
+    if (platform == EGL_PLATFORM_ANGLE_ANGLE)
+    {
+        return egl::Display::GetDisplayFromNativeDisplay(
+            gl::bitCast<EGLNativeDisplayType>(native_display), attribMap);
+    }
+    else if (platform == EGL_PLATFORM_DEVICE_EXT)
+    {
+        Device *eglDevice = static_cast<Device *>(native_display);
+        return egl::Display::GetDisplayFromDevice(eglDevice, attribMap);
+    }
+    else
+    {
+        UNREACHABLE();
+        return EGL_NO_DISPLAY;
+    }
+}
+
+EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy,
+                                                       EGLConfig config,
+                                                       void *native_window,
+                                                       const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", void* native_window = 0x%016" PRIxPTR
+          ", "
+          "const EGLint* attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_window, (uintptr_t)attrib_list);
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+
+    UNIMPLEMENTED();
+    thread->setError(EglBadDisplay() << "eglCreatePlatformWindowSurface unimplemented.", GetDebug(),
+                     "eglCreatePlatformWindowSurface", GetDisplayIfValid(display));
+    return EGL_NO_SURFACE;
+}
+
+EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy,
+                                                       EGLConfig config,
+                                                       void *native_pixmap,
+                                                       const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", void* native_pixmap = 0x%016" PRIxPTR
+          ", "
+          "const EGLint* attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_pixmap, (uintptr_t)attrib_list);
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+
+    UNIMPLEMENTED();
+    thread->setError(EglBadDisplay() << "eglCreatePlatformPixmapSurface unimplemented.", GetDebug(),
+                     "eglCreatePlatformPixmapSurface", GetDisplayIfValid(display));
+    return EGL_NO_SURFACE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy =0x%016" PRIxPTR "p, EGLSync sync = 0x%016" PRIxPTR
+          ", EGLint flags = 0x%X)",
+          (uintptr_t)dpy, (uintptr_t)sync, flags);
+
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    gl::Context *context  = thread->getContext();
+    egl::Sync *syncObject = static_cast<Sync *>(sync);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateWaitSync(display, context, syncObject, flags),
+                         "eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    gl::Context *currentContext = thread->getContext();
+    ANGLE_EGL_TRY_RETURN(thread, syncObject->serverWait(display, currentContext, flags),
+                         "eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+__eglMustCastToProperFunctionPointerType EGLAPIENTRY EGL_GetProcAddress(const char *procname)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(const char *procname = \"%s\")", procname);
+    Thread *thread = egl::GetCurrentThread();
+
+    ProcEntry *entry =
+        std::lower_bound(&g_procTable[0], &g_procTable[g_numProcs], procname, CompareProc);
+
+    thread->setSuccess();
+
+    if (entry == &g_procTable[g_numProcs] || strcmp(entry->first, procname) != 0)
+    {
+        return nullptr;
+    }
+
+    return entry->second;
+}
+}  // extern "C"
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_egl.h b/gfx/angle/checkout/src/libGLESv2/entry_points_egl.h
new file mode 100644
index 0000000000..85a86ddc96
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_egl.h
@@ -0,0 +1,136 @@
+//
+// Copyright(c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// entry_points_egl.h : Defines the EGL entry points.
+
+#ifndef LIBGLESV2_ENTRYPOINTSEGL_H_
+#define LIBGLESV2_ENTRYPOINTSEGL_H_
+
+#include <EGL/egl.h>
+#include <export.h>
+
+extern "C" {
+
+// EGL 1.0
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy,
+                                                     const EGLint *attrib_list,
+                                                     EGLConfig *configs,
+                                                     EGLint config_size,
+                                                     EGLint *num_config);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy,
+                                                    EGLSurface surface,
+                                                    EGLNativePixmapType target);
+ANGLE_EXPORT EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy,
+                                                      EGLConfig config,
+                                                      EGLContext share_context,
+                                                      const EGLint *attrib_list);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy,
+                                                             EGLConfig config,
+                                                             const EGLint *attrib_list);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy,
+                                                            EGLConfig config,
+                                                            EGLNativePixmapType pixmap,
+                                                            const EGLint *attrib_list);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy,
+                                                            EGLConfig config,
+                                                            EGLNativeWindowType win,
+                                                            const EGLint *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy,
+                                                        EGLConfig config,
+                                                        EGLint attribute,
+                                                        EGLint *value);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy,
+                                                   EGLConfig *configs,
+                                                   EGLint config_size,
+                                                   EGLint *num_config);
+ANGLE_EXPORT EGLDisplay EGLAPIENTRY EGL_GetCurrentDisplay(void);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_GetCurrentSurface(EGLint readdraw);
+ANGLE_EXPORT EGLDisplay EGLAPIENTRY EGL_GetDisplay(EGLNativeDisplayType display_id);
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_GetError(void);
+ANGLE_EXPORT __eglMustCastToProperFunctionPointerType EGLAPIENTRY
+EGL_GetProcAddress(const char *procname);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy,
+                                                    EGLSurface draw,
+                                                    EGLSurface read,
+                                                    EGLContext ctx);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy,
+                                                     EGLContext ctx,
+                                                     EGLint attribute,
+                                                     EGLint *value);
+ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy,
+                                                     EGLSurface surface,
+                                                     EGLint attribute,
+                                                     EGLint *value);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitGL(void);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine);
+
+// EGL 1.1
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy,
+                                                     EGLSurface surface,
+                                                     EGLint buffer);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy,
+                                                        EGLSurface surface,
+                                                        EGLint buffer);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy,
+                                                      EGLSurface surface,
+                                                      EGLint attribute,
+                                                      EGLint value);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval);
+
+// EGL 1.2
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_BindAPI(EGLenum api);
+ANGLE_EXPORT EGLenum EGLAPIENTRY EGL_QueryAPI(void);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy,
+                                                                      EGLenum buftype,
+                                                                      EGLClientBuffer buffer,
+                                                                      EGLConfig config,
+                                                                      const EGLint *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseThread(void);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitClient(void);
+
+// EGL 1.4
+ANGLE_EXPORT EGLContext EGLAPIENTRY EGL_GetCurrentContext(void);
+
+// EGL 1.5
+ANGLE_EXPORT EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy,
+                                                EGLenum type,
+                                                const EGLAttrib *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync);
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy,
+                                                   EGLSync sync,
+                                                   EGLint flags,
+                                                   EGLTime timeout);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy,
+                                                      EGLSync sync,
+                                                      EGLint attribute,
+                                                      EGLAttrib *value);
+ANGLE_EXPORT EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy,
+                                                  EGLContext ctx,
+                                                  EGLenum target,
+                                                  EGLClientBuffer buffer,
+                                                  const EGLAttrib *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image);
+ANGLE_EXPORT EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform,
+                                                           void *native_display,
+                                                           const EGLAttrib *attrib_list);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy,
+                                                                    EGLConfig config,
+                                                                    void *native_window,
+                                                                    const EGLAttrib *attrib_list);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy,
+                                                                    EGLConfig config,
+                                                                    void *native_pixmap,
+                                                                    const EGLAttrib *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags);
+}  // extern "C"
+
+#endif  // LIBGLESV2_ENTRYPOINTSEGL_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext.cpp
new file mode 100644
index 0000000000..55823b8059
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext.cpp
@@ -0,0 +1,1480 @@
+//
+// Copyright(c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// entry_points_ext.cpp : Implements the EGL extension entry points.
+
+#include "libGLESv2/entry_points_egl_ext.h"
+
+#include "common/debug.h"
+#include "libANGLE/Context.h"
+#include "libANGLE/Device.h"
+#include "libANGLE/Display.h"
+#include "libANGLE/EGLSync.h"
+#include "libANGLE/Stream.h"
+#include "libANGLE/Surface.h"
+#include "libANGLE/Thread.h"
+#include "libANGLE/queryutils.h"
+#include "libANGLE/validationEGL.h"
+#include "libGLESv2/global_state.h"
+
+using namespace egl;
+
+extern "C" {
+
+// EGL_ANGLE_query_surface_pointer
+EGLBoolean EGLAPIENTRY EGL_QuerySurfacePointerANGLE(EGLDisplay dpy,
+                                                    EGLSurface surface,
+                                                    EGLint attribute,
+                                                    void **value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint attribute = %d, void "
+          "**value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)surface, attribute, (uintptr_t)value);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    Error error = ValidateSurface(display, eglSurface);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglQuerySurfacePointerANGLE",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    if (!display->getExtensions().querySurfacePointer)
+    {
+        thread->setSuccess();
+        return EGL_FALSE;
+    }
+
+    if (surface == EGL_NO_SURFACE)
+    {
+        thread->setError(EglBadSurface(), GetDebug(), "eglQuerySurfacePointerANGLE",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    // validate the attribute parameter
+    switch (attribute)
+    {
+        case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE:
+            if (!display->getExtensions().surfaceD3DTexture2DShareHandle)
+            {
+                thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
+                                 GetSurfaceIfValid(display, eglSurface));
+                return EGL_FALSE;
+            }
+            break;
+        case EGL_DXGI_KEYED_MUTEX_ANGLE:
+            if (!display->getExtensions().keyedMutex)
+            {
+                thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
+                                 GetSurfaceIfValid(display, eglSurface));
+                return EGL_FALSE;
+            }
+            break;
+        default:
+            thread->setError(EglBadAttribute(), GetDebug(), "eglQuerySurfacePointerANGLE",
+                             GetSurfaceIfValid(display, eglSurface));
+            return EGL_FALSE;
+    }
+
+    error = eglSurface->querySurfacePointerANGLE(attribute, value);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglQuerySurfacePointerANGLE",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL_NV_post_sub_buffer
+EGLBoolean EGLAPIENTRY EGL_PostSubBufferNV(EGLDisplay dpy,
+                                           EGLSurface surface,
+                                           EGLint x,
+                                           EGLint y,
+                                           EGLint width,
+                                           EGLint height)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint x = %d, EGLint y = %d, "
+          "EGLint width = %d, EGLint height = %d)",
+          (uintptr_t)dpy, (uintptr_t)surface, x, y, width, height);
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    if (x < 0 || y < 0 || width < 0 || height < 0)
+    {
+        thread->setError(EglBadParameter(), GetDebug(), "eglPostSubBufferNV",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    Error error = ValidateSurface(display, eglSurface);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglPostSubBufferNV",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    if (display->testDeviceLost())
+    {
+        thread->setError(EglContextLost(), GetDebug(), "eglPostSubBufferNV",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    if (surface == EGL_NO_SURFACE)
+    {
+        thread->setError(EglBadSurface(), GetDebug(), "eglPostSubBufferNV",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    if (!display->getExtensions().postSubBuffer)
+    {
+        // Spec is not clear about how this should be handled.
+        thread->setSuccess();
+        return EGL_TRUE;
+    }
+
+    // TODO(jmadill): Validate Surface is bound to the thread.
+    error = eglSurface->postSubBuffer(thread->getContext(), x, y, width, height);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglPostSubBufferNV",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL_EXT_platform_base
+EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform,
+                                                 void *native_display,
+                                                 const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLenum platform = %d, void* native_display = 0x%016" PRIxPTR
+          ", const EGLint* attrib_list = "
+          "0x%016" PRIxPTR ")",
+          platform, (uintptr_t)native_display, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    Error err = ValidateGetPlatformDisplayEXT(platform, native_display, attrib_list);
+    thread->setError(err, GetDebug(), "eglGetPlatformDisplayEXT", GetThreadIfValid(thread));
+    if (err.isError())
+    {
+        return EGL_NO_DISPLAY;
+    }
+
+    const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
+    if (platform == EGL_PLATFORM_ANGLE_ANGLE)
+    {
+        return egl::Display::GetDisplayFromNativeDisplay(
+            gl::bitCast<EGLNativeDisplayType>(native_display), attribMap);
+    }
+    else if (platform == EGL_PLATFORM_DEVICE_EXT)
+    {
+        Device *eglDevice = static_cast<Device *>(native_display);
+        return egl::Display::GetDisplayFromDevice(eglDevice, attribMap);
+    }
+    else
+    {
+        UNREACHABLE();
+        return EGL_NO_DISPLAY;
+    }
+}
+
+EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy,
+                                                          EGLConfig config,
+                                                          void *native_window,
+                                                          const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", void *native_window = 0x%016" PRIxPTR
+          ", "
+          "const EGLint *attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_window, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    Config *configuration   = static_cast<Config *>(config);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
+
+    ANGLE_EGL_TRY_RETURN(
+        thread,
+        ValidateCreatePlatformWindowSurfaceEXT(display, configuration, native_window, attributes),
+        "eglCreatePlatformWindowSurfaceEXT", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    thread->setError(EglBadDisplay() << "CreatePlatformWindowSurfaceEXT unimplemented.", GetDebug(),
+                     "eglCreatePlatformWindowSurfaceEXT", GetDisplayIfValid(display));
+    return EGL_NO_SURFACE;
+}
+
+EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy,
+                                                          EGLConfig config,
+                                                          void *native_pixmap,
+                                                          const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLConfig config = 0x%016" PRIxPTR
+          ", void *native_pixmap = 0x%016" PRIxPTR
+          ", "
+          "const EGLint *attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_pixmap, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    Config *configuration   = static_cast<Config *>(config);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
+
+    ANGLE_EGL_TRY_RETURN(
+        thread,
+        ValidateCreatePlatformPixmapSurfaceEXT(display, configuration, native_pixmap, attributes),
+        "eglCreatePlatformPixmapSurfaceEXT", GetDisplayIfValid(display), EGL_NO_SURFACE);
+
+    thread->setError(EglBadDisplay() << "CreatePlatformPixmapSurfaceEXT unimplemented.", GetDebug(),
+                     "eglCreatePlatformPixmapSurfaceEXT", GetDisplayIfValid(display));
+    return EGL_NO_SURFACE;
+}
+
+// EGL_EXT_device_query
+EGLBoolean EGLAPIENTRY EGL_QueryDeviceAttribEXT(EGLDeviceEXT device,
+                                                EGLint attribute,
+                                                EGLAttrib *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDeviceEXT device = 0x%016" PRIxPTR
+          ", EGLint attribute = %d, EGLAttrib *value = 0x%016" PRIxPTR ")",
+          (uintptr_t)device, attribute, (uintptr_t)value);
+    Thread *thread = egl::GetCurrentThread();
+
+    Device *dev = static_cast<Device *>(device);
+
+    Error error = ValidateDevice(dev);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglQueryDeviceAttribEXT", GetDeviceIfValid(dev));
+        return EGL_FALSE;
+    }
+
+    // If the device was created by (and is owned by) a display, and that display doesn't support
+    // device querying, then this call should fail
+    egl::Display *owningDisplay = dev->getOwningDisplay();
+    if (owningDisplay != nullptr && !owningDisplay->getExtensions().deviceQuery)
+    {
+        thread->setError(EglBadAccess() << "Device wasn't created using eglCreateDeviceANGLE, "
+                                           "and the egl::Display that created it doesn't support "
+                                           "device querying",
+                         GetDebug(), "eglQueryDeviceAttribEXT", GetDeviceIfValid(dev));
+        return EGL_FALSE;
+    }
+
+    // validate the attribute parameter
+    switch (attribute)
+    {
+        case EGL_D3D11_DEVICE_ANGLE:
+        case EGL_D3D9_DEVICE_ANGLE:
+            if (!dev->getExtensions().deviceD3D || dev->getType() != attribute)
+            {
+                thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
+                                 GetDeviceIfValid(dev));
+                return EGL_FALSE;
+            }
+            error = dev->getDevice(value);
+            if (error.isError())
+            {
+                thread->setError(error, GetDebug(), "eglQueryDeviceAttribEXT",
+                                 GetDeviceIfValid(dev));
+                return EGL_FALSE;
+            }
+            break;
+        default:
+            thread->setError(EglBadAttribute(), GetDebug(), "eglQueryDeviceAttribEXT",
+                             GetDeviceIfValid(dev));
+            return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL_EXT_device_query
+const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDeviceEXT device = 0x%016" PRIxPTR ", EGLint name = %d)", (uintptr_t)device, name);
+    Thread *thread = egl::GetCurrentThread();
+
+    Device *dev = static_cast<Device *>(device);
+
+    Error error = ValidateDevice(dev);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglQueryDeviceStringEXT", GetDeviceIfValid(dev));
+        return EGL_FALSE;
+    }
+
+    const char *result;
+    switch (name)
+    {
+        case EGL_EXTENSIONS:
+            result = dev->getExtensionString().c_str();
+            break;
+        default:
+            thread->setError(EglBadDevice(), GetDebug(), "eglQueryDeviceStringEXT",
+                             GetDeviceIfValid(dev));
+            return nullptr;
+    }
+
+    thread->setSuccess();
+    return result;
+}
+
+// EGL_EXT_device_query
+EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR
+          ", EGLint attribute = %d, EGLAttrib *value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, attribute, (uintptr_t)value);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateQueryDisplayAttribEXT(display, attribute),
+                         "eglQueryDisplayAttribEXT", GetDisplayIfValid(display), EGL_FALSE);
+
+    *value = display->queryAttrib(attribute);
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL_ANGLE_feature_control
+EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy,
+                                                   EGLint attribute,
+                                                   EGLAttrib *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR
+          ", EGLint attribute = %d, EGLAttrib *value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, attribute, (uintptr_t)value);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateQueryDisplayAttribANGLE(display, attribute),
+                         "eglQueryDisplayAttribANGLE", GetDisplayIfValid(display), EGL_FALSE);
+
+    *value = display->queryAttrib(attribute);
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+ANGLE_EXPORT EGLImageKHR EGLAPIENTRY EGL_CreateImageKHR(EGLDisplay dpy,
+                                                        EGLContext ctx,
+                                                        EGLenum target,
+                                                        EGLClientBuffer buffer,
+                                                        const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLContext ctx = 0x%016" PRIxPTR
+          ", EGLenum target = 0x%X, "
+          "EGLClientBuffer buffer = 0x%016" PRIxPTR
+          ", const EGLAttrib *attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)ctx, target, (uintptr_t)buffer, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    gl::Context *context    = static_cast<gl::Context *>(ctx);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
+
+    Error error = ValidateCreateImageKHR(display, context, target, buffer, attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateImageKHR", GetDisplayIfValid(display));
+        return EGL_NO_IMAGE;
+    }
+
+    Image *image = nullptr;
+    error        = display->createImage(context, target, buffer, attributes, &image);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateImageKHR", GetDisplayIfValid(display));
+        return EGL_NO_IMAGE;
+    }
+
+    thread->setSuccess();
+    return static_cast<EGLImage>(image);
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLImage image = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)image);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Image *img            = static_cast<Image *>(image);
+
+    Error error = ValidateDestroyImageKHR(display, img);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglDestroyImageKHR", GetImageIfValid(display, img));
+        return EGL_FALSE;
+    }
+
+    display->destroyImage(img);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY EGL_CreateDeviceANGLE(EGLint device_type,
+                                                            void *native_device,
+                                                            const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLint device_type = %d, void* native_device = 0x%016" PRIxPTR
+          ", const EGLAttrib* attrib_list = "
+          "0x%016" PRIxPTR ")",
+          device_type, (uintptr_t)native_device, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    Error error = ValidateCreateDeviceANGLE(device_type, native_device, attrib_list);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateDeviceANGLE", GetThreadIfValid(thread));
+        return EGL_NO_DEVICE_EXT;
+    }
+
+    Device *device = nullptr;
+    error          = Device::CreateDevice(device_type, native_device, &device);
+    if (error.isError())
+    {
+        ASSERT(device == nullptr);
+        thread->setError(error, GetDebug(), "eglCreateDeviceANGLE", GetThreadIfValid(thread));
+        return EGL_NO_DEVICE_EXT;
+    }
+
+    thread->setSuccess();
+    return device;
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseDeviceANGLE(EGLDeviceEXT device)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDeviceEXT device = 0x%016" PRIxPTR ")", (uintptr_t)device);
+    Thread *thread = egl::GetCurrentThread();
+
+    Device *dev = static_cast<Device *>(device);
+
+    Error error = ValidateReleaseDeviceANGLE(dev);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglReleaseDeviceANGLE", GetDeviceIfValid(dev));
+        return EGL_FALSE;
+    }
+
+    SafeDelete(dev);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL_KHR_stream
+EGLStreamKHR EGLAPIENTRY EGL_CreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", const EGLAttrib* attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
+
+    Error error = ValidateCreateStreamKHR(display, attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateStreamKHR", GetDisplayIfValid(display));
+        return EGL_NO_STREAM_KHR;
+    }
+
+    Stream *stream;
+    error = display->createStream(attributes, &stream);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateStreamKHR", GetDisplayIfValid(display));
+        return EGL_NO_STREAM_KHR;
+    }
+
+    thread->setSuccess();
+    return static_cast<EGLStreamKHR>(stream);
+}
+
+EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR = 0x%016" PRIxPTR ")", (uintptr_t)dpy,
+          (uintptr_t)stream);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Stream *streamObject  = static_cast<Stream *>(stream);
+
+    Error error = ValidateDestroyStreamKHR(display, streamObject);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglDestroyStreamKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    display->destroyStream(streamObject);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy,
+                                           EGLStreamKHR stream,
+                                           EGLenum attribute,
+                                           EGLint value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
+          ", EGLenum attribute = 0x%X, "
+          "EGLint value = 0x%X)",
+          (uintptr_t)dpy, (uintptr_t)stream, attribute, value);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Stream *streamObject  = static_cast<Stream *>(stream);
+
+    Error error = ValidateStreamAttribKHR(display, streamObject, attribute, value);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamAttribKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    switch (attribute)
+    {
+        case EGL_CONSUMER_LATENCY_USEC_KHR:
+            streamObject->setConsumerLatency(value);
+            break;
+        case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR:
+            streamObject->setConsumerAcquireTimeout(value);
+            break;
+        default:
+            UNREACHABLE();
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy,
+                                          EGLStreamKHR stream,
+                                          EGLenum attribute,
+                                          EGLint *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
+          ", EGLenum attribute = 0x%X, "
+          "EGLint value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)stream, attribute, (uintptr_t)value);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Stream *streamObject  = static_cast<Stream *>(stream);
+
+    Error error = ValidateQueryStreamKHR(display, streamObject, attribute, value);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglQueryStreamKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    switch (attribute)
+    {
+        case EGL_STREAM_STATE_KHR:
+            *value = streamObject->getState();
+            break;
+        case EGL_CONSUMER_LATENCY_USEC_KHR:
+            *value = streamObject->getConsumerLatency();
+            break;
+        case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR:
+            *value = streamObject->getConsumerAcquireTimeout();
+            break;
+        default:
+            UNREACHABLE();
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy,
+                                             EGLStreamKHR stream,
+                                             EGLenum attribute,
+                                             EGLuint64KHR *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
+          ", EGLenum attribute = 0x%X, "
+          "EGLuint64KHR value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)stream, attribute, (uintptr_t)value);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Stream *streamObject  = static_cast<Stream *>(stream);
+
+    Error error = ValidateQueryStreamu64KHR(display, streamObject, attribute, value);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglQueryStreamu64KHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    switch (attribute)
+    {
+        case EGL_PRODUCER_FRAME_KHR:
+            *value = streamObject->getProducerFrame();
+            break;
+        case EGL_CONSUMER_FRAME_KHR:
+            *value = streamObject->getConsumerFrame();
+            break;
+        default:
+            UNREACHABLE();
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR = 0x%016" PRIxPTR ")", (uintptr_t)dpy,
+          (uintptr_t)stream);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Stream *streamObject  = static_cast<Stream *>(stream);
+    gl::Context *context  = gl::GetValidGlobalContext();
+
+    Error error = ValidateStreamConsumerGLTextureExternalKHR(display, context, streamObject);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    error = streamObject->createConsumerGLTextureExternal(AttributeMap(), context);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR = 0x%016" PRIxPTR ")", (uintptr_t)dpy,
+          (uintptr_t)stream);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Stream *streamObject  = static_cast<Stream *>(stream);
+    gl::Context *context  = gl::GetValidGlobalContext();
+
+    Error error = ValidateStreamConsumerAcquireKHR(display, context, streamObject);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamConsumerAcquireKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    error = streamObject->consumerAcquire(context);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamConsumerAcquireKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR = 0x%016" PRIxPTR ")", (uintptr_t)dpy,
+          (uintptr_t)stream);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Stream *streamObject  = static_cast<Stream *>(stream);
+    gl::Context *context  = gl::GetValidGlobalContext();
+
+    Error error = ValidateStreamConsumerReleaseKHR(display, context, streamObject);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglSStreamConsumerReleaseKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    error = streamObject->consumerRelease(context);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamConsumerReleaseKHR",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
+                                                                    EGLStreamKHR stream,
+                                                                    const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
+          ", EGLAttrib attrib_list = 0x%016" PRIxPTR "",
+          (uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    Stream *streamObject    = static_cast<Stream *>(stream);
+    gl::Context *context    = gl::GetValidGlobalContext();
+    AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
+
+    Error error = ValidateStreamConsumerGLTextureExternalAttribsNV(display, context, streamObject,
+                                                                   attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalAttribsNV",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    error = streamObject->createConsumerGLTextureExternal(attributes, context);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamConsumerGLTextureExternalAttribsNV",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy,
+                                                               EGLStreamKHR stream,
+                                                               const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
+          ", EGLAttrib attrib_list = 0x%016" PRIxPTR "",
+          (uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    Stream *streamObject    = static_cast<Stream *>(stream);
+    AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
+
+    Error error = ValidateCreateStreamProducerD3DTextureANGLE(display, streamObject, attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateStreamProducerD3DTextureANGLE",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    error = streamObject->createProducerD3D11Texture(attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglCreateStreamProducerD3DTextureANGLE",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy,
+                                                     EGLStreamKHR stream,
+                                                     void *texture,
+                                                     const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLStreamKHR stream = 0x%016" PRIxPTR
+          ", void* texture = 0x%016" PRIxPTR
+          ", "
+          "EGLAttrib attrib_list = 0x%016" PRIxPTR "",
+          (uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)texture, (uintptr_t)attrib_list);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    Stream *streamObject    = static_cast<Stream *>(stream);
+    AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
+
+    Error error = ValidateStreamPostD3DTextureANGLE(display, streamObject, texture, attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamPostD3DTextureANGLE",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    error = streamObject->postD3D11Texture(texture, attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglStreamPostD3DTextureANGLE",
+                         GetStreamIfValid(display, streamObject));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL_KHR_fence_sync
+ANGLE_EXPORT EGLSync EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy,
+                                                   EGLenum type,
+                                                   const EGLint *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR
+          ", EGLenum type = 0x%X, const EGLint* attrib_list = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, type, (uintptr_t)attrib_list);
+
+    Thread *thread          = egl::GetCurrentThread();
+    egl::Display *display   = static_cast<egl::Display *>(dpy);
+    AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
+
+    gl::Context *currentContext  = thread->getContext();
+    egl::Display *currentDisplay = currentContext ? currentContext->getDisplay() : nullptr;
+
+    ANGLE_EGL_TRY_RETURN(
+        thread, ValidateCreateSyncKHR(display, type, attributes, currentDisplay, currentContext),
+        "eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
+
+    egl::Sync *syncObject = nullptr;
+    ANGLE_EGL_TRY_RETURN(thread, display->createSync(currentContext, type, attributes, &syncObject),
+                         "eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC);
+
+    thread->setSuccess();
+    return static_cast<EGLSync>(syncObject);
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSync sync)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR ")", (uintptr_t)dpy,
+          (uintptr_t)sync);
+
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    egl::Sync *syncObject = static_cast<Sync *>(sync);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateDestroySync(display, syncObject), "eglDestroySync",
+                         GetDisplayIfValid(display), EGL_FALSE);
+
+    display->destroySync(syncObject);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy,
+                                                      EGLSync sync,
+                                                      EGLint flags,
+                                                      EGLTime timeout)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR
+          ", EGLint flags = 0x%X, EGLTime timeout = "
+          "%llu)",
+          (uintptr_t)dpy, (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout));
+
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    egl::Sync *syncObject = static_cast<Sync *>(sync);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateClientWaitSync(display, syncObject, flags, timeout),
+                         "eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    gl::Context *currentContext = thread->getContext();
+    EGLint syncStatus           = EGL_FALSE;
+    ANGLE_EGL_TRY_RETURN(
+        thread, syncObject->clientWait(display, currentContext, flags, timeout, &syncStatus),
+        "eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    thread->setSuccess();
+    return syncStatus;
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy,
+                                                         EGLSync sync,
+                                                         EGLint attribute,
+                                                         EGLint *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSync sync = 0x%016" PRIxPTR
+          ", EGLint attribute = 0x%X, EGLAttrib "
+          "*value = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)sync, attribute, (uintptr_t)value);
+
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    egl::Sync *syncObject = static_cast<Sync *>(sync);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateGetSyncAttribKHR(display, syncObject, attribute, value),
+                         "eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    ANGLE_EGL_TRY_RETURN(thread, GetSyncAttrib(display, syncObject, attribute, value),
+                         "eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL_KHR_wait_sync
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSync sync, EGLint flags)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy =0x%016" PRIxPTR "p, EGLSync sync = 0x%016" PRIxPTR
+          ", EGLint flags = 0x%X)",
+          (uintptr_t)dpy, (uintptr_t)sync, flags);
+
+    Thread *thread        = egl::GetCurrentThread();
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    gl::Context *context  = thread->getContext();
+    egl::Sync *syncObject = static_cast<Sync *>(sync);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateWaitSync(display, context, syncObject, flags),
+                         "eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    gl::Context *currentContext = thread->getContext();
+    ANGLE_EGL_TRY_RETURN(thread, syncObject->serverWait(display, currentContext, flags),
+                         "eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_GetSyncValuesCHROMIUM(EGLDisplay dpy,
+                                                 EGLSurface surface,
+                                                 EGLuint64KHR *ust,
+                                                 EGLuint64KHR *msc,
+                                                 EGLuint64KHR *sbc)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLuint64KHR* ust = 0x%016" PRIxPTR
+          ", "
+          "EGLuint64KHR* msc = 0x%016" PRIxPTR ", EGLuint64KHR* sbc = 0x%016" PRIxPTR "",
+          (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)ust, (uintptr_t)msc, (uintptr_t)sbc);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    Error error = ValidateGetSyncValuesCHROMIUM(display, eglSurface, ust, msc, sbc);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglGetSyncValuesCHROMIUM",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    error = eglSurface->getSyncValues(ust, msc, sbc);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglGetSyncValuesCHROMIUM",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithDamageKHR(EGLDisplay dpy,
+                                                    EGLSurface surface,
+                                                    EGLint *rects,
+                                                    EGLint n_rects)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint *rects = 0x%016" PRIxPTR
+          ", EGLint "
+          "n_rects = %d)",
+          (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)rects, n_rects);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    Error error = ValidateSwapBuffersWithDamageKHR(display, eglSurface, rects, n_rects);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglSwapBuffersWithDamageEXT",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    error = eglSurface->swapWithDamage(thread->getContext(), rects, n_rects);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglSwapBuffersWithDamageEXT",
+                         GetSurfaceIfValid(display, eglSurface));
+        return EGL_FALSE;
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLBoolean EGLAPIENTRY EGL_PresentationTimeANDROID(EGLDisplay dpy,
+                                                   EGLSurface surface,
+                                                   EGLnsecsANDROID time)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLnsecsANDROID time = %llu)",
+          (uintptr_t)dpy, (uintptr_t)surface, static_cast<unsigned long long>(time));
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidatePresentationTimeANDROID(display, eglSurface, time),
+                         "eglPresentationTimeANDROID", GetSurfaceIfValid(display, eglSurface),
+                         EGL_FALSE);
+    ANGLE_EGL_TRY_RETURN(thread, eglSurface->setPresentationTime(time),
+                         "eglPresentationTimeANDROID", GetSurfaceIfValid(display, eglSurface),
+                         EGL_FALSE);
+
+    return EGL_TRUE;
+}
+
+ANGLE_EXPORT void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy,
+                                                           EGLSetBlobFuncANDROID set,
+                                                           EGLGetBlobFuncANDROID get)
+{
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSetBlobFuncANDROID set = 0x%016" PRIxPTR
+          ", EGLGetBlobFuncANDROID get "
+          "= 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)set, (uintptr_t)get);
+    Thread *thread = egl::GetCurrentThread();
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+
+    ANGLE_EGL_TRY(thread, ValidateSetBlobCacheANDROID(display, set, get),
+                  "eglSetBlobCacheFuncsANDROID", GetDisplayIfValid(display));
+
+    thread->setSuccess();
+    display->setBlobCacheFuncs(set, get);
+}
+
+EGLint EGLAPIENTRY EGL_ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLenum attrib = 0x%X)", (uintptr_t)dpy, attrib);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateProgramCacheGetAttribANGLE(display, attrib),
+                         "eglProgramCacheGetAttribANGLE", GetDisplayIfValid(display), 0);
+
+    thread->setSuccess();
+    return display->programCacheGetAttrib(attrib);
+}
+
+void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy,
+                                            EGLint index,
+                                            void *key,
+                                            EGLint *keysize,
+                                            void *binary,
+                                            EGLint *binarysize)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint index = %d, void *key = 0x%016" PRIxPTR
+          ", EGLint *keysize = "
+          "0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR ", EGLint *size = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, index, (uintptr_t)key, (uintptr_t)keysize, (uintptr_t)binary,
+          (uintptr_t)binarysize);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY(thread,
+                  ValidateProgramCacheQueryANGLE(display, index, key, keysize, binary, binarysize),
+                  "eglProgramCacheQueryANGLE", GetDisplayIfValid(display));
+
+    ANGLE_EGL_TRY(thread, display->programCacheQuery(index, key, keysize, binary, binarysize),
+                  "eglProgramCacheQueryANGLE", GetDisplayIfValid(display));
+
+    thread->setSuccess();
+}
+
+void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy,
+                                               const void *key,
+                                               EGLint keysize,
+                                               const void *binary,
+                                               EGLint binarysize)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", void *key = 0x%016" PRIxPTR
+          ", EGLint keysize = %d, void *binary = "
+          "0x%016" PRIxPTR ", EGLint size = %d)",
+          (uintptr_t)dpy, (uintptr_t)key, keysize, (uintptr_t)binary, binarysize);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY(thread,
+                  ValidateProgramCachePopulateANGLE(display, key, keysize, binary, binarysize),
+                  "eglProgramCachePopulateANGLE", GetDisplayIfValid(display));
+
+    ANGLE_EGL_TRY(thread, display->programCachePopulate(key, keysize, binary, binarysize),
+                  "eglProgramCachePopulateANGLE", GetDisplayIfValid(display));
+
+    thread->setSuccess();
+}
+
+EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGLenum mode)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint limit = %d, EGLenum mode = 0x%X)",
+          (uintptr_t)dpy, limit, mode);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateProgramCacheResizeANGLE(display, limit, mode),
+                         "eglProgramCacheResizeANGLE", GetDisplayIfValid(display), 0);
+
+    thread->setSuccess();
+    return display->programCacheResize(limit, mode);
+}
+
+EGLint EGLAPIENTRY EGL_DebugMessageControlKHR(EGLDEBUGPROCKHR callback,
+                                              const EGLAttrib *attrib_list)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDEBUGPROCKHR callback = 0x%016" PRIxPTR ", EGLAttrib attrib_list = 0x%016" PRIxPTR
+          ")",
+          (uintptr_t)callback, (uintptr_t)attrib_list);
+
+    Thread *thread = egl::GetCurrentThread();
+
+    AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
+
+    Error error = ValidateDebugMessageControlKHR(callback, attributes);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglDebugMessageControlKHR", nullptr);
+        return error.getCode();
+    }
+
+    Debug *debug = GetDebug();
+    debug->setCallback(callback, attributes);
+
+    thread->setSuccess();
+    return EGL_SUCCESS;
+}
+
+EGLBoolean EGLAPIENTRY EGL_QueryDebugKHR(EGLint attribute, EGLAttrib *value)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLint attribute = 0x%X, EGLAttrib* value = 0x%016" PRIxPTR ")", attribute,
+          (uintptr_t)value);
+
+    Thread *thread = egl::GetCurrentThread();
+
+    Error error = ValidateQueryDebugKHR(attribute, value);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglQueryDebugKHR", nullptr);
+        return EGL_FALSE;
+    }
+
+    Debug *debug = GetDebug();
+    switch (attribute)
+    {
+        case EGL_DEBUG_MSG_CRITICAL_KHR:
+        case EGL_DEBUG_MSG_ERROR_KHR:
+        case EGL_DEBUG_MSG_WARN_KHR:
+        case EGL_DEBUG_MSG_INFO_KHR:
+            *value = debug->isMessageTypeEnabled(FromEGLenum<MessageType>(attribute)) ? EGL_TRUE
+                                                                                      : EGL_FALSE;
+            break;
+        case EGL_DEBUG_CALLBACK_KHR:
+            *value = reinterpret_cast<EGLAttrib>(debug->getCallback());
+            break;
+
+        default:
+            UNREACHABLE();
+    }
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay dpy,
+                                      EGLenum objectType,
+                                      EGLObjectKHR object,
+                                      EGLLabelKHR label)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR
+          ", EGLenum objectType = 0x%X, EGLObjectKHR object = 0x%016" PRIxPTR
+          ", "
+          "EGLLabelKHR label = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, objectType, (uintptr_t)object, (uintptr_t)label);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ObjectType objectTypePacked = FromEGLenum<ObjectType>(objectType);
+    Error error = ValidateLabelObjectKHR(thread, display, objectTypePacked, object, label);
+    if (error.isError())
+    {
+        thread->setError(error, GetDebug(), "eglLabelObjectKHR",
+                         GetLabeledObjectIfValid(thread, display, objectTypePacked, object));
+        return error.getCode();
+    }
+
+    LabeledObject *labeledObject =
+        GetLabeledObjectIfValid(thread, display, objectTypePacked, object);
+    ASSERT(labeledObject != nullptr);
+    labeledObject->setLabel(label);
+
+    thread->setSuccess();
+    return EGL_SUCCESS;
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingSupportedANDROID(EGLDisplay dpy,
+                                                                            EGLSurface surface,
+                                                                            EGLint name)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint name = 0x%X)",
+          (uintptr_t)dpy, (uintptr_t)surface, name);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+    Thread *thread        = egl::GetCurrentThread();
+
+    CompositorTiming nameInternal = FromEGLenum<CompositorTiming>(name);
+
+    ANGLE_EGL_TRY_RETURN(
+        thread, ValidateGetCompositorTimingSupportedANDROID(display, eglSurface, nameInternal),
+        "eglQueryTimestampSupportedANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    thread->setSuccess();
+    return eglSurface->getSupportedCompositorTimings().test(nameInternal);
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy,
+                                                                   EGLSurface surface,
+                                                                   EGLint numTimestamps,
+                                                                   const EGLint *names,
+                                                                   EGLnsecsANDROID *values)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint numTimestamps = %d, const EGLint *names = 0x%016" PRIxPTR
+          ", EGLnsecsANDROID *values = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)surface, numTimestamps, (uintptr_t)names, (uintptr_t)values);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(
+        thread,
+        ValidateGetCompositorTimingANDROID(display, eglSurface, numTimestamps, names, values),
+        "eglGetCompositorTimingANDROIDD", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+    ANGLE_EGL_TRY_RETURN(thread, eglSurface->getCompositorTiming(numTimestamps, names, values),
+                         "eglGetCompositorTimingANDROIDD", GetSurfaceIfValid(display, eglSurface),
+                         EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy,
+                                                              EGLSurface surface,
+                                                              EGLuint64KHR *frameId)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLuint64KHR *frameId = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)frameId);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateGetNextFrameIdANDROID(display, eglSurface, frameId),
+                         "eglGetNextFrameIdANDROID", GetSurfaceIfValid(display, eglSurface),
+                         EGL_FALSE);
+    ANGLE_EGL_TRY_RETURN(thread, eglSurface->getNextFrameId(frameId), "eglGetNextFrameIdANDROID",
+                         GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDisplay dpy,
+                                                                          EGLSurface surface,
+                                                                          EGLint timestamp)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLint timestamp = 0x%X)",
+          (uintptr_t)dpy, (uintptr_t)surface, timestamp);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+    Thread *thread        = egl::GetCurrentThread();
+
+    Timestamp timestampInternal = FromEGLenum<Timestamp>(timestamp);
+
+    ANGLE_EGL_TRY_RETURN(
+        thread, ValidateGetFrameTimestampSupportedANDROID(display, eglSurface, timestampInternal),
+        "eglQueryTimestampSupportedANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    thread->setSuccess();
+    return eglSurface->getSupportedTimestamps().test(timestampInternal);
+}
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy,
+                                                                  EGLSurface surface,
+                                                                  EGLuint64KHR frameId,
+                                                                  EGLint numTimestamps,
+                                                                  const EGLint *timestamps,
+                                                                  EGLnsecsANDROID *values)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSurface surface = 0x%016" PRIxPTR
+          ", EGLuint64KHR frameId = %llu, EGLint numTimestamps = %d, const EGLint *timestamps = "
+          "0x%016" PRIxPTR ", EGLnsecsANDROID *values = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)surface, (unsigned long long)frameId, numTimestamps,
+          (uintptr_t)timestamps, (uintptr_t)values);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Surface *eglSurface   = static_cast<Surface *>(surface);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread,
+                         ValidateGetFrameTimestampsANDROID(display, eglSurface, frameId,
+                                                           numTimestamps, timestamps, values),
+                         "eglGetFrameTimestampsANDROID", GetSurfaceIfValid(display, eglSurface),
+                         EGL_FALSE);
+    ANGLE_EGL_TRY_RETURN(
+        thread, eglSurface->getFrameTimestamps(frameId, numTimestamps, timestamps, values),
+        "eglGetFrameTimestampsANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE);
+
+    thread->setSuccess();
+    return EGL_TRUE;
+}
+
+// EGL_ANGLE_feature_control
+ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryStringiANGLE(EGLDisplay dpy,
+                                                           EGLint name,
+                                                           EGLint index)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLint name = %d, EGLint index = %d)",
+          (uintptr_t)dpy, name, index);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateQueryStringiANGLE(display, name, index),
+                         "eglQueryStringiANGLE", GetDisplayIfValid(display), nullptr);
+
+    thread->setSuccess();
+    return display->queryStringi(name, index);
+}
+
+EGLClientBuffer EGLAPIENTRY EGL_GetNativeClientBufferANDROID(const struct AHardwareBuffer *buffer)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(const struct AHardwareBuffer *buffer = 0x%016" PRIxPTR ")", (uintptr_t)buffer);
+
+    Thread *thread = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateGetNativeClientBufferANDROID(buffer),
+                         "eglGetNativeClientBufferANDROID", nullptr, nullptr);
+
+    thread->setSuccess();
+    return egl::Display::GetNativeClientBuffer(buffer);
+}
+
+EGLint EGLAPIENTRY EGL_DupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync)
+{
+    ANGLE_SCOPED_GLOBAL_LOCK();
+    EVENT("(EGLDisplay dpy = 0x%016" PRIxPTR ", EGLSyncKHR sync = 0x%016" PRIxPTR ")",
+          (uintptr_t)dpy, (uintptr_t)sync);
+
+    egl::Display *display = static_cast<egl::Display *>(dpy);
+    Sync *syncObject      = static_cast<Sync *>(sync);
+    Thread *thread        = egl::GetCurrentThread();
+
+    ANGLE_EGL_TRY_RETURN(thread, ValidateDupNativeFenceFDANDROID(display, syncObject),
+                         "eglDupNativeFenceFDANDROID", GetSyncIfValid(display, syncObject),
+                         EGL_NO_NATIVE_FENCE_FD_ANDROID);
+
+    EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID;
+    ANGLE_EGL_TRY_RETURN(thread, syncObject->dupNativeFenceFD(display, &result),
+                         "eglDupNativeFenceFDANDROID", GetSyncIfValid(display, syncObject),
+                         EGL_NO_NATIVE_FENCE_FD_ANDROID);
+
+    thread->setSuccess();
+    return result;
+}
+
+}  // extern "C"
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext.h b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext.h
new file mode 100644
index 0000000000..37aa94619d
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext.h
@@ -0,0 +1,222 @@
+//
+// Copyright(c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// entry_points_egl_ext.h : Defines the EGL extension entry points.
+
+#ifndef LIBGLESV2_ENTRYPOINTSEGLEXT_H_
+#define LIBGLESV2_ENTRYPOINTSEGLEXT_H_
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <export.h>
+
+extern "C" {
+
+// EGL_ANGLE_query_surface_pointer
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QuerySurfacePointerANGLE(EGLDisplay dpy,
+                                                                 EGLSurface surface,
+                                                                 EGLint attribute,
+                                                                 void **value);
+
+// EGL_NV_post_sub_buffer
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_PostSubBufferNV(EGLDisplay dpy,
+                                                        EGLSurface surface,
+                                                        EGLint x,
+                                                        EGLint y,
+                                                        EGLint width,
+                                                        EGLint height);
+
+// EGL_EXT_platform_base
+ANGLE_EXPORT EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform,
+                                                              void *native_display,
+                                                              const EGLint *attrib_list);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy,
+                                                                       EGLConfig config,
+                                                                       void *native_window,
+                                                                       const EGLint *attrib_list);
+ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy,
+                                                                       EGLConfig config,
+                                                                       void *native_pixmap,
+                                                                       const EGLint *attrib_list);
+
+// EGL_EXT_device_query
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy,
+                                                              EGLint attribute,
+                                                              EGLAttrib *value);
+
+// EGL_ANGLE_feature_control
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy,
+                                                                EGLint attribute,
+                                                                EGLAttrib *value);
+
+// EGL_EXT_device_query
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDeviceAttribEXT(EGLDeviceEXT device,
+                                                             EGLint attribute,
+                                                             EGLAttrib *value);
+ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name);
+
+// EGL_KHR_image_base/EGL_KHR_image
+ANGLE_EXPORT EGLImageKHR EGLAPIENTRY EGL_CreateImageKHR(EGLDisplay dpy,
+                                                        EGLContext ctx,
+                                                        EGLenum target,
+                                                        EGLClientBuffer buffer,
+                                                        const EGLint *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image);
+
+// EGL_ANGLE_device_creation
+ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY EGL_CreateDeviceANGLE(EGLint device_type,
+                                                            void *native_device,
+                                                            const EGLAttrib *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseDeviceANGLE(EGLDeviceEXT device);
+
+// EGL_KHR_stream
+ANGLE_EXPORT EGLStreamKHR EGLAPIENTRY EGL_CreateStreamKHR(EGLDisplay dpy,
+                                                          const EGLint *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy,
+                                                        EGLStreamKHR stream,
+                                                        EGLenum attribute,
+                                                        EGLint value);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy,
+                                                       EGLStreamKHR stream,
+                                                       EGLenum attribute,
+                                                       EGLint *value);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy,
+                                                          EGLStreamKHR stream,
+                                                          EGLenum attribute,
+                                                          EGLuint64KHR *value);
+
+// EGL_KHR_stream_consumer_gltexture
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy,
+                                                                           EGLStreamKHR stream);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy,
+                                                                 EGLStreamKHR stream);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy,
+                                                                 EGLStreamKHR stream);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY
+EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
+                                             EGLStreamKHR stream,
+                                             const EGLAttrib *attrib_list);
+
+// EGL_ANGLE_stream_producer_d3d_texture
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY
+EGL_CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy,
+                                        EGLStreamKHR stream,
+                                        const EGLAttrib *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy,
+                                                                  EGLStreamKHR stream,
+                                                                  void *texture,
+                                                                  const EGLAttrib *attrib_list);
+
+// EGL_KHR_fence_sync
+ANGLE_EXPORT EGLSync EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy,
+                                                   EGLenum type,
+                                                   const EGLint *attrib_list);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSync sync);
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy,
+                                                      EGLSync sync,
+                                                      EGLint flags,
+                                                      EGLTime timeout);
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy,
+                                                         EGLSync sync,
+                                                         EGLint attribute,
+                                                         EGLint *value);
+
+// EGL_KHR_wait_sync
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSync sync, EGLint flags);
+
+// EGL_CHROMIUM_get_sync_values
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncValuesCHROMIUM(EGLDisplay dpy,
+                                                              EGLSurface surface,
+                                                              EGLuint64KHR *ust,
+                                                              EGLuint64KHR *msc,
+                                                              EGLuint64KHR *sbc);
+
+// EGL_KHR_swap_buffers_with_damage
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithDamageKHR(EGLDisplay dpy,
+                                                                 EGLSurface surface,
+                                                                 EGLint *rects,
+                                                                 EGLint n_rects);
+
+// EGL_ANDROID_presentation_time
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_PresentationTimeANDROID(EGLDisplay dpy,
+                                                                EGLSurface surface,
+                                                                EGLnsecsANDROID time);
+
+// EGL_ANDRIOD_blob_cache
+ANGLE_EXPORT void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy,
+                                                           EGLSetBlobFuncANDROID set,
+                                                           EGLGetBlobFuncANDROID get);
+
+// EGL_ANGLE_program_cache_control
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib);
+ANGLE_EXPORT void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy,
+                                                         EGLint index,
+                                                         void *key,
+                                                         EGLint *keysize,
+                                                         void *binary,
+                                                         EGLint *binarysize);
+ANGLE_EXPORT void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy,
+                                                            const void *key,
+                                                            EGLint keysize,
+                                                            const void *binary,
+                                                            EGLint binarysize);
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy,
+                                                            EGLint limit,
+                                                            EGLenum mode);
+
+// EGL_KHR_debug
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_DebugMessageControlKHR(EGLDEBUGPROCKHR callback,
+                                                           const EGLAttrib *attrib_list);
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDebugKHR(EGLint attribute, EGLAttrib *value);
+
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay display,
+                                                   EGLenum objectType,
+                                                   EGLObjectKHR object,
+                                                   EGLLabelKHR label);
+
+// ANDROID_get_frame_timestamps
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingSupportedANDROID(EGLDisplay dpy,
+                                                                            EGLSurface surface,
+                                                                            EGLint name);
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy,
+                                                                   EGLSurface surface,
+                                                                   EGLint numTimestamps,
+                                                                   const EGLint *names,
+                                                                   EGLnsecsANDROID *values);
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy,
+                                                              EGLSurface surface,
+                                                              EGLuint64KHR *frameId);
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDisplay dpy,
+                                                                          EGLSurface surface,
+                                                                          EGLint timestamp);
+
+ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy,
+                                                                  EGLSurface surface,
+                                                                  EGLuint64KHR frameId,
+                                                                  EGLint numTimestamps,
+                                                                  const EGLint *timestamps,
+                                                                  EGLnsecsANDROID *values);
+
+// EGL_ANGLE_feature_control
+ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryStringiANGLE(EGLDisplay dpy,
+                                                           EGLint name,
+                                                           EGLint index);
+
+// EGL_ANDROID_get_native_client_buffer
+ANGLE_EXPORT EGLClientBuffer EGLAPIENTRY
+EGL_GetNativeClientBufferANDROID(const struct AHardwareBuffer *buffer);
+
+// EGL_ANDROID_native_fence_sync
+ANGLE_EXPORT EGLint EGLAPIENTRY EGL_DupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync);
+
+}  // extern "C"
+
+#endif  // LIBGLESV2_ENTRYPOINTSEGLEXT_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.cpp
new file mode 100644
index 0000000000..c210033aaa
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.cpp
@@ -0,0 +1,1429 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_1_0_autogen.cpp:
+//   Defines the GLES 1.0 entry points.
+
+#include "libGLESv2/entry_points_gles_1_0_autogen.h"
+
+#include "libANGLE/Context.h"
+#include "libANGLE/Context.inl.h"
+#include "libANGLE/capture_gles_1_0_autogen.h"
+#include "libANGLE/entry_points_utils.h"
+#include "libANGLE/validationES1.h"
+#include "libGLESv2/global_state.h"
+
+namespace gl
+{
+void GL_APIENTRY AlphaFunc(GLenum func, GLfloat ref)
+{
+    EVENT("(GLenum func = 0x%X, GLfloat ref = %f)", func, ref);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        AlphaTestFunc funcPacked = FromGLenum<AlphaTestFunc>(func);
+        ANGLE_CAPTURE(AlphaFunc, context, funcPacked, ref);
+        if (context->skipValidation() || ValidateAlphaFunc(context, funcPacked, ref))
+        {
+            context->alphaFunc(funcPacked, ref);
+        }
+    }
+}
+
+void GL_APIENTRY AlphaFuncx(GLenum func, GLfixed ref)
+{
+    EVENT("(GLenum func = 0x%X, GLfixed ref = 0x%X)", func, ref);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        AlphaTestFunc funcPacked = FromGLenum<AlphaTestFunc>(func);
+        ANGLE_CAPTURE(AlphaFuncx, context, funcPacked, ref);
+        if (context->skipValidation() || ValidateAlphaFuncx(context, funcPacked, ref))
+        {
+            context->alphaFuncx(funcPacked, ref);
+        }
+    }
+}
+
+void GL_APIENTRY ClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+    EVENT("(GLfixed red = 0x%X, GLfixed green = 0x%X, GLfixed blue = 0x%X, GLfixed alpha = 0x%X)",
+          red, green, blue, alpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearColorx, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateClearColorx(context, red, green, blue, alpha))
+        {
+            context->clearColorx(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY ClearDepthx(GLfixed depth)
+{
+    EVENT("(GLfixed depth = 0x%X)", depth);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearDepthx, context, depth);
+        if (context->skipValidation() || ValidateClearDepthx(context, depth))
+        {
+            context->clearDepthx(depth);
+        }
+    }
+}
+
+void GL_APIENTRY ClientActiveTexture(GLenum texture)
+{
+    EVENT("(GLenum texture = 0x%X)", texture);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClientActiveTexture, context, texture);
+        if (context->skipValidation() || ValidateClientActiveTexture(context, texture))
+        {
+            context->clientActiveTexture(texture);
+        }
+    }
+}
+
+void GL_APIENTRY ClipPlanef(GLenum p, const GLfloat *eqn)
+{
+    EVENT("(GLenum p = 0x%X, const GLfloat *eqn = 0x%016" PRIxPTR ")", p, (uintptr_t)eqn);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClipPlanef, context, p, eqn);
+        if (context->skipValidation() || ValidateClipPlanef(context, p, eqn))
+        {
+            context->clipPlanef(p, eqn);
+        }
+    }
+}
+
+void GL_APIENTRY ClipPlanex(GLenum plane, const GLfixed *equation)
+{
+    EVENT("(GLenum plane = 0x%X, const GLfixed *equation = 0x%016" PRIxPTR ")", plane,
+          (uintptr_t)equation);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClipPlanex, context, plane, equation);
+        if (context->skipValidation() || ValidateClipPlanex(context, plane, equation))
+        {
+            context->clipPlanex(plane, equation);
+        }
+    }
+}
+
+void GL_APIENTRY Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
+          green, blue, alpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Color4f, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateColor4f(context, red, green, blue, alpha))
+        {
+            context->color4f(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+    EVENT("(GLubyte red = %d, GLubyte green = %d, GLubyte blue = %d, GLubyte alpha = %d)", red,
+          green, blue, alpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Color4ub, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateColor4ub(context, red, green, blue, alpha))
+        {
+            context->color4ub(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+    EVENT("(GLfixed red = 0x%X, GLfixed green = 0x%X, GLfixed blue = 0x%X, GLfixed alpha = 0x%X)",
+          red, green, blue, alpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Color4x, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateColor4x(context, red, green, blue, alpha))
+        {
+            context->color4x(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY ColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(ColorPointer, context, size, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateColorPointer(context, size, typePacked, stride, pointer))
+        {
+            context->colorPointer(size, typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY DepthRangex(GLfixed n, GLfixed f)
+{
+    EVENT("(GLfixed n = 0x%X, GLfixed f = 0x%X)", n, f);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DepthRangex, context, n, f);
+        if (context->skipValidation() || ValidateDepthRangex(context, n, f))
+        {
+            context->depthRangex(n, f);
+        }
+    }
+}
+
+void GL_APIENTRY DisableClientState(GLenum array)
+{
+    EVENT("(GLenum array = 0x%X)", array);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ClientVertexArrayType arrayPacked = FromGLenum<ClientVertexArrayType>(array);
+        ANGLE_CAPTURE(DisableClientState, context, arrayPacked);
+        if (context->skipValidation() || ValidateDisableClientState(context, arrayPacked))
+        {
+            context->disableClientState(arrayPacked);
+        }
+    }
+}
+
+void GL_APIENTRY EnableClientState(GLenum array)
+{
+    EVENT("(GLenum array = 0x%X)", array);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ClientVertexArrayType arrayPacked = FromGLenum<ClientVertexArrayType>(array);
+        ANGLE_CAPTURE(EnableClientState, context, arrayPacked);
+        if (context->skipValidation() || ValidateEnableClientState(context, arrayPacked))
+        {
+            context->enableClientState(arrayPacked);
+        }
+    }
+}
+
+void GL_APIENTRY Fogf(GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Fogf, context, pname, param);
+        if (context->skipValidation() || ValidateFogf(context, pname, param))
+        {
+            context->fogf(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY Fogfv(GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Fogfv, context, pname, params);
+        if (context->skipValidation() || ValidateFogfv(context, pname, params))
+        {
+            context->fogfv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY Fogx(GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfixed param = 0x%X)", pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Fogx, context, pname, param);
+        if (context->skipValidation() || ValidateFogx(context, pname, param))
+        {
+            context->fogx(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY Fogxv(GLenum pname, const GLfixed *param)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfixed *param = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Fogxv, context, pname, param);
+        if (context->skipValidation() || ValidateFogxv(context, pname, param))
+        {
+            context->fogxv(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY Frustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
+{
+    EVENT(
+        "(GLfloat l = %f, GLfloat r = %f, GLfloat b = %f, GLfloat t = %f, GLfloat n = %f, GLfloat "
+        "f = %f)",
+        l, r, b, t, n, f);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Frustumf, context, l, r, b, t, n, f);
+        if (context->skipValidation() || ValidateFrustumf(context, l, r, b, t, n, f))
+        {
+            context->frustumf(l, r, b, t, n, f);
+        }
+    }
+}
+
+void GL_APIENTRY Frustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
+{
+    EVENT(
+        "(GLfixed l = 0x%X, GLfixed r = 0x%X, GLfixed b = 0x%X, GLfixed t = 0x%X, GLfixed n = "
+        "0x%X, GLfixed f = 0x%X)",
+        l, r, b, t, n, f);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Frustumx, context, l, r, b, t, n, f);
+        if (context->skipValidation() || ValidateFrustumx(context, l, r, b, t, n, f))
+        {
+            context->frustumx(l, r, b, t, n, f);
+        }
+    }
+}
+
+void GL_APIENTRY GetClipPlanef(GLenum plane, GLfloat *equation)
+{
+    EVENT("(GLenum plane = 0x%X, GLfloat *equation = 0x%016" PRIxPTR ")", plane,
+          (uintptr_t)equation);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetClipPlanef, context, plane, equation);
+        if (context->skipValidation() || ValidateGetClipPlanef(context, plane, equation))
+        {
+            context->getClipPlanef(plane, equation);
+        }
+    }
+}
+
+void GL_APIENTRY GetClipPlanex(GLenum plane, GLfixed *equation)
+{
+    EVENT("(GLenum plane = 0x%X, GLfixed *equation = 0x%016" PRIxPTR ")", plane,
+          (uintptr_t)equation);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetClipPlanex, context, plane, equation);
+        if (context->skipValidation() || ValidateGetClipPlanex(context, plane, equation))
+        {
+            context->getClipPlanex(plane, equation);
+        }
+    }
+}
+
+void GL_APIENTRY GetFixedv(GLenum pname, GLfixed *params)
+{
+    EVENT("(GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")", pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFixedv, context, pname, params);
+        if (context->skipValidation() || ValidateGetFixedv(context, pname, params))
+        {
+            context->getFixedv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")", light,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(GetLightfv, context, light, pnamePacked, params);
+        if (context->skipValidation() || ValidateGetLightfv(context, light, pnamePacked, params))
+        {
+            context->getLightfv(light, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetLightxv(GLenum light, GLenum pname, GLfixed *params)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")", light,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(GetLightxv, context, light, pnamePacked, params);
+        if (context->skipValidation() || ValidateGetLightxv(context, light, pnamePacked, params))
+        {
+            context->getLightxv(light, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")", face,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(GetMaterialfv, context, face, pnamePacked, params);
+        if (context->skipValidation() || ValidateGetMaterialfv(context, face, pnamePacked, params))
+        {
+            context->getMaterialfv(face, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")", face,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(GetMaterialxv, context, face, pnamePacked, params);
+        if (context->skipValidation() || ValidateGetMaterialxv(context, face, pnamePacked, params))
+        {
+            context->getMaterialxv(face, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetPointerv(GLenum pname, void **params)
+{
+    EVENT("(GLenum pname = 0x%X, void **params = 0x%016" PRIxPTR ")", pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetPointerv, context, pname, params);
+        if (context->skipValidation() || ValidateGetPointerv(context, pname, params))
+        {
+            context->getPointerv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(GetTexEnvfv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateGetTexEnvfv(context, targetPacked, pnamePacked, params))
+        {
+            context->getTexEnvfv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(GetTexEnviv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateGetTexEnviv(context, targetPacked, pnamePacked, params))
+        {
+            context->getTexEnviv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(GetTexEnvxv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateGetTexEnvxv(context, targetPacked, pnamePacked, params))
+        {
+            context->getTexEnvxv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterxv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameterxv(context, targetPacked, pname, params))
+        {
+            context->getTexParameterxv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY LightModelf(GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LightModelf, context, pname, param);
+        if (context->skipValidation() || ValidateLightModelf(context, pname, param))
+        {
+            context->lightModelf(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY LightModelfv(GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LightModelfv, context, pname, params);
+        if (context->skipValidation() || ValidateLightModelfv(context, pname, params))
+        {
+            context->lightModelfv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY LightModelx(GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfixed param = 0x%X)", pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LightModelx, context, pname, param);
+        if (context->skipValidation() || ValidateLightModelx(context, pname, param))
+        {
+            context->lightModelx(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY LightModelxv(GLenum pname, const GLfixed *param)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfixed *param = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LightModelxv, context, pname, param);
+        if (context->skipValidation() || ValidateLightModelxv(context, pname, param))
+        {
+            context->lightModelxv(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY Lightf(GLenum light, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", light, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(Lightf, context, light, pnamePacked, param);
+        if (context->skipValidation() || ValidateLightf(context, light, pnamePacked, param))
+        {
+            context->lightf(light, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY Lightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          light, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(Lightfv, context, light, pnamePacked, params);
+        if (context->skipValidation() || ValidateLightfv(context, light, pnamePacked, params))
+        {
+            context->lightfv(light, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY Lightx(GLenum light, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", light, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(Lightx, context, light, pnamePacked, param);
+        if (context->skipValidation() || ValidateLightx(context, light, pnamePacked, param))
+        {
+            context->lightx(light, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY Lightxv(GLenum light, GLenum pname, const GLfixed *params)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")",
+          light, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(Lightxv, context, light, pnamePacked, params);
+        if (context->skipValidation() || ValidateLightxv(context, light, pnamePacked, params))
+        {
+            context->lightxv(light, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY LineWidthx(GLfixed width)
+{
+    EVENT("(GLfixed width = 0x%X)", width);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LineWidthx, context, width);
+        if (context->skipValidation() || ValidateLineWidthx(context, width))
+        {
+            context->lineWidthx(width);
+        }
+    }
+}
+
+void GL_APIENTRY LoadIdentity()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LoadIdentity, context);
+        if (context->skipValidation() || ValidateLoadIdentity(context))
+        {
+            context->loadIdentity();
+        }
+    }
+}
+
+void GL_APIENTRY LoadMatrixf(const GLfloat *m)
+{
+    EVENT("(const GLfloat *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LoadMatrixf, context, m);
+        if (context->skipValidation() || ValidateLoadMatrixf(context, m))
+        {
+            context->loadMatrixf(m);
+        }
+    }
+}
+
+void GL_APIENTRY LoadMatrixx(const GLfixed *m)
+{
+    EVENT("(const GLfixed *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LoadMatrixx, context, m);
+        if (context->skipValidation() || ValidateLoadMatrixx(context, m))
+        {
+            context->loadMatrixx(m);
+        }
+    }
+}
+
+void GL_APIENTRY LogicOp(GLenum opcode)
+{
+    EVENT("(GLenum opcode = 0x%X)", opcode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        LogicalOperation opcodePacked = FromGLenum<LogicalOperation>(opcode);
+        ANGLE_CAPTURE(LogicOp, context, opcodePacked);
+        if (context->skipValidation() || ValidateLogicOp(context, opcodePacked))
+        {
+            context->logicOp(opcodePacked);
+        }
+    }
+}
+
+void GL_APIENTRY Materialf(GLenum face, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", face, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(Materialf, context, face, pnamePacked, param);
+        if (context->skipValidation() || ValidateMaterialf(context, face, pnamePacked, param))
+        {
+            context->materialf(face, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY Materialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          face, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(Materialfv, context, face, pnamePacked, params);
+        if (context->skipValidation() || ValidateMaterialfv(context, face, pnamePacked, params))
+        {
+            context->materialfv(face, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY Materialx(GLenum face, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", face, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(Materialx, context, face, pnamePacked, param);
+        if (context->skipValidation() || ValidateMaterialx(context, face, pnamePacked, param))
+        {
+            context->materialx(face, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY Materialxv(GLenum face, GLenum pname, const GLfixed *param)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, const GLfixed *param = 0x%016" PRIxPTR ")",
+          face, pname, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(Materialxv, context, face, pnamePacked, param);
+        if (context->skipValidation() || ValidateMaterialxv(context, face, pnamePacked, param))
+        {
+            context->materialxv(face, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY MatrixMode(GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        MatrixType modePacked = FromGLenum<MatrixType>(mode);
+        ANGLE_CAPTURE(MatrixMode, context, modePacked);
+        if (context->skipValidation() || ValidateMatrixMode(context, modePacked))
+        {
+            context->matrixMode(modePacked);
+        }
+    }
+}
+
+void GL_APIENTRY MultMatrixf(const GLfloat *m)
+{
+    EVENT("(const GLfloat *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MultMatrixf, context, m);
+        if (context->skipValidation() || ValidateMultMatrixf(context, m))
+        {
+            context->multMatrixf(m);
+        }
+    }
+}
+
+void GL_APIENTRY MultMatrixx(const GLfixed *m)
+{
+    EVENT("(const GLfixed *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MultMatrixx, context, m);
+        if (context->skipValidation() || ValidateMultMatrixx(context, m))
+        {
+            context->multMatrixx(m);
+        }
+    }
+}
+
+void GL_APIENTRY MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+    EVENT("(GLenum target = 0x%X, GLfloat s = %f, GLfloat t = %f, GLfloat r = %f, GLfloat q = %f)",
+          target, s, t, r, q);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MultiTexCoord4f, context, target, s, t, r, q);
+        if (context->skipValidation() || ValidateMultiTexCoord4f(context, target, s, t, r, q))
+        {
+            context->multiTexCoord4f(target, s, t, r, q);
+        }
+    }
+}
+
+void GL_APIENTRY MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
+{
+    EVENT(
+        "(GLenum texture = 0x%X, GLfixed s = 0x%X, GLfixed t = 0x%X, GLfixed r = 0x%X, GLfixed q = "
+        "0x%X)",
+        texture, s, t, r, q);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MultiTexCoord4x, context, texture, s, t, r, q);
+        if (context->skipValidation() || ValidateMultiTexCoord4x(context, texture, s, t, r, q))
+        {
+            context->multiTexCoord4x(texture, s, t, r, q);
+        }
+    }
+}
+
+void GL_APIENTRY Normal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+    EVENT("(GLfloat nx = %f, GLfloat ny = %f, GLfloat nz = %f)", nx, ny, nz);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Normal3f, context, nx, ny, nz);
+        if (context->skipValidation() || ValidateNormal3f(context, nx, ny, nz))
+        {
+            context->normal3f(nx, ny, nz);
+        }
+    }
+}
+
+void GL_APIENTRY Normal3x(GLfixed nx, GLfixed ny, GLfixed nz)
+{
+    EVENT("(GLfixed nx = 0x%X, GLfixed ny = 0x%X, GLfixed nz = 0x%X)", nx, ny, nz);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Normal3x, context, nx, ny, nz);
+        if (context->skipValidation() || ValidateNormal3x(context, nx, ny, nz))
+        {
+            context->normal3x(nx, ny, nz);
+        }
+    }
+}
+
+void GL_APIENTRY NormalPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+    EVENT("(GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR ")",
+          type, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(NormalPointer, context, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateNormalPointer(context, typePacked, stride, pointer))
+        {
+            context->normalPointer(typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY Orthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
+{
+    EVENT(
+        "(GLfloat l = %f, GLfloat r = %f, GLfloat b = %f, GLfloat t = %f, GLfloat n = %f, GLfloat "
+        "f = %f)",
+        l, r, b, t, n, f);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Orthof, context, l, r, b, t, n, f);
+        if (context->skipValidation() || ValidateOrthof(context, l, r, b, t, n, f))
+        {
+            context->orthof(l, r, b, t, n, f);
+        }
+    }
+}
+
+void GL_APIENTRY Orthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
+{
+    EVENT(
+        "(GLfixed l = 0x%X, GLfixed r = 0x%X, GLfixed b = 0x%X, GLfixed t = 0x%X, GLfixed n = "
+        "0x%X, GLfixed f = 0x%X)",
+        l, r, b, t, n, f);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Orthox, context, l, r, b, t, n, f);
+        if (context->skipValidation() || ValidateOrthox(context, l, r, b, t, n, f))
+        {
+            context->orthox(l, r, b, t, n, f);
+        }
+    }
+}
+
+void GL_APIENTRY PointParameterf(GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PointParameter pnamePacked = FromGLenum<PointParameter>(pname);
+        ANGLE_CAPTURE(PointParameterf, context, pnamePacked, param);
+        if (context->skipValidation() || ValidatePointParameterf(context, pnamePacked, param))
+        {
+            context->pointParameterf(pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY PointParameterfv(GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PointParameter pnamePacked = FromGLenum<PointParameter>(pname);
+        ANGLE_CAPTURE(PointParameterfv, context, pnamePacked, params);
+        if (context->skipValidation() || ValidatePointParameterfv(context, pnamePacked, params))
+        {
+            context->pointParameterfv(pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY PointParameterx(GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfixed param = 0x%X)", pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PointParameter pnamePacked = FromGLenum<PointParameter>(pname);
+        ANGLE_CAPTURE(PointParameterx, context, pnamePacked, param);
+        if (context->skipValidation() || ValidatePointParameterx(context, pnamePacked, param))
+        {
+            context->pointParameterx(pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY PointParameterxv(GLenum pname, const GLfixed *params)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PointParameter pnamePacked = FromGLenum<PointParameter>(pname);
+        ANGLE_CAPTURE(PointParameterxv, context, pnamePacked, params);
+        if (context->skipValidation() || ValidatePointParameterxv(context, pnamePacked, params))
+        {
+            context->pointParameterxv(pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY PointSize(GLfloat size)
+{
+    EVENT("(GLfloat size = %f)", size);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PointSize, context, size);
+        if (context->skipValidation() || ValidatePointSize(context, size))
+        {
+            context->pointSize(size);
+        }
+    }
+}
+
+void GL_APIENTRY PointSizex(GLfixed size)
+{
+    EVENT("(GLfixed size = 0x%X)", size);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PointSizex, context, size);
+        if (context->skipValidation() || ValidatePointSizex(context, size))
+        {
+            context->pointSizex(size);
+        }
+    }
+}
+
+void GL_APIENTRY PolygonOffsetx(GLfixed factor, GLfixed units)
+{
+    EVENT("(GLfixed factor = 0x%X, GLfixed units = 0x%X)", factor, units);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PolygonOffsetx, context, factor, units);
+        if (context->skipValidation() || ValidatePolygonOffsetx(context, factor, units))
+        {
+            context->polygonOffsetx(factor, units);
+        }
+    }
+}
+
+void GL_APIENTRY PopMatrix()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PopMatrix, context);
+        if (context->skipValidation() || ValidatePopMatrix(context))
+        {
+            context->popMatrix();
+        }
+    }
+}
+
+void GL_APIENTRY PushMatrix()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PushMatrix, context);
+        if (context->skipValidation() || ValidatePushMatrix(context))
+        {
+            context->pushMatrix();
+        }
+    }
+}
+
+void GL_APIENTRY Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+    EVENT("(GLfloat angle = %f, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", angle, x, y, z);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Rotatef, context, angle, x, y, z);
+        if (context->skipValidation() || ValidateRotatef(context, angle, x, y, z))
+        {
+            context->rotatef(angle, x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
+{
+    EVENT("(GLfixed angle = 0x%X, GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X)", angle, x,
+          y, z);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Rotatex, context, angle, x, y, z);
+        if (context->skipValidation() || ValidateRotatex(context, angle, x, y, z))
+        {
+            context->rotatex(angle, x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY SampleCoveragex(GLclampx value, GLboolean invert)
+{
+    EVENT("(GLclampx value = 0x%X, GLboolean invert = %u)", value, invert);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SampleCoveragex, context, value, invert);
+        if (context->skipValidation() || ValidateSampleCoveragex(context, value, invert))
+        {
+            context->sampleCoveragex(value, invert);
+        }
+    }
+}
+
+void GL_APIENTRY Scalef(GLfloat x, GLfloat y, GLfloat z)
+{
+    EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Scalef, context, x, y, z);
+        if (context->skipValidation() || ValidateScalef(context, x, y, z))
+        {
+            context->scalef(x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY Scalex(GLfixed x, GLfixed y, GLfixed z)
+{
+    EVENT("(GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X)", x, y, z);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Scalex, context, x, y, z);
+        if (context->skipValidation() || ValidateScalex(context, x, y, z))
+        {
+            context->scalex(x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY ShadeModel(GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ShadingModel modePacked = FromGLenum<ShadingModel>(mode);
+        ANGLE_CAPTURE(ShadeModel, context, modePacked);
+        if (context->skipValidation() || ValidateShadeModel(context, modePacked))
+        {
+            context->shadeModel(modePacked);
+        }
+    }
+}
+
+void GL_APIENTRY TexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(TexCoordPointer, context, size, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateTexCoordPointer(context, size, typePacked, stride, pointer))
+        {
+            context->texCoordPointer(size, typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", target, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvf, context, targetPacked, pnamePacked, param);
+        if (context->skipValidation() || ValidateTexEnvf(context, targetPacked, pnamePacked, param))
+        {
+            context->texEnvf(targetPacked, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvfv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateTexEnvfv(context, targetPacked, pnamePacked, params))
+        {
+            context->texEnvfv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvi(GLenum target, GLenum pname, GLint param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvi, context, targetPacked, pnamePacked, param);
+        if (context->skipValidation() || ValidateTexEnvi(context, targetPacked, pnamePacked, param))
+        {
+            context->texEnvi(targetPacked, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnviv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateTexEnviv(context, targetPacked, pnamePacked, params))
+        {
+            context->texEnviv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvx(GLenum target, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", target, pname,
+          param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvx, context, targetPacked, pnamePacked, param);
+        if (context->skipValidation() || ValidateTexEnvx(context, targetPacked, pnamePacked, param))
+        {
+            context->texEnvx(targetPacked, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvxv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateTexEnvxv(context, targetPacked, pnamePacked, params))
+        {
+            context->texEnvxv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterx(GLenum target, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", target, pname,
+          param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterx, context, targetPacked, pname, param);
+        if (context->skipValidation() || ValidateTexParameterx(context, targetPacked, pname, param))
+        {
+            context->texParameterx(targetPacked, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterxv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterxv(context, targetPacked, pname, params))
+        {
+            context->texParameterxv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY Translatef(GLfloat x, GLfloat y, GLfloat z)
+{
+    EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Translatef, context, x, y, z);
+        if (context->skipValidation() || ValidateTranslatef(context, x, y, z))
+        {
+            context->translatef(x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY Translatex(GLfixed x, GLfixed y, GLfixed z)
+{
+    EVENT("(GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X)", x, y, z);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Translatex, context, x, y, z);
+        if (context->skipValidation() || ValidateTranslatex(context, x, y, z))
+        {
+            context->translatex(x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY VertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexPointer, context, size, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateVertexPointer(context, size, typePacked, stride, pointer))
+        {
+            context->vertexPointer(size, typePacked, stride, pointer);
+        }
+    }
+}
+}  // namespace gl
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.h
new file mode 100644
index 0000000000..ba098f51b9
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.h
@@ -0,0 +1,122 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_1_0_autogen.h:
+//   Defines the GLES 1.0 entry points.
+
+#ifndef LIBGLESV2_ENTRY_POINTS_GLES_1_0_AUTOGEN_H_
+#define LIBGLESV2_ENTRY_POINTS_GLES_1_0_AUTOGEN_H_
+
+#include <GLES/gl.h>
+#include <export.h>
+
+namespace gl
+{
+ANGLE_EXPORT void GL_APIENTRY AlphaFunc(GLenum func, GLfloat ref);
+ANGLE_EXPORT void GL_APIENTRY AlphaFuncx(GLenum func, GLfixed ref);
+ANGLE_EXPORT void GL_APIENTRY ClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
+ANGLE_EXPORT void GL_APIENTRY ClearDepthx(GLfixed depth);
+ANGLE_EXPORT void GL_APIENTRY ClientActiveTexture(GLenum texture);
+ANGLE_EXPORT void GL_APIENTRY ClipPlanef(GLenum p, const GLfloat *eqn);
+ANGLE_EXPORT void GL_APIENTRY ClipPlanex(GLenum plane, const GLfixed *equation);
+ANGLE_EXPORT void GL_APIENTRY Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ANGLE_EXPORT void GL_APIENTRY Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+ANGLE_EXPORT void GL_APIENTRY Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
+ANGLE_EXPORT void GL_APIENTRY ColorPointer(GLint size,
+                                           GLenum type,
+                                           GLsizei stride,
+                                           const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY DepthRangex(GLfixed n, GLfixed f);
+ANGLE_EXPORT void GL_APIENTRY DisableClientState(GLenum array);
+ANGLE_EXPORT void GL_APIENTRY EnableClientState(GLenum array);
+ANGLE_EXPORT void GL_APIENTRY Fogf(GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY Fogfv(GLenum pname, const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY Fogx(GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY Fogxv(GLenum pname, const GLfixed *param);
+ANGLE_EXPORT void GL_APIENTRY
+Frustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f);
+ANGLE_EXPORT void GL_APIENTRY
+Frustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f);
+ANGLE_EXPORT void GL_APIENTRY GetClipPlanef(GLenum plane, GLfloat *equation);
+ANGLE_EXPORT void GL_APIENTRY GetClipPlanex(GLenum plane, GLfixed *equation);
+ANGLE_EXPORT void GL_APIENTRY GetFixedv(GLenum pname, GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetLightfv(GLenum light, GLenum pname, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetLightxv(GLenum light, GLenum pname, GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetMaterialfv(GLenum face, GLenum pname, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetMaterialxv(GLenum face, GLenum pname, GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetPointerv(GLenum pname, void **params);
+ANGLE_EXPORT void GL_APIENTRY GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexEnviv(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterxv(GLenum target, GLenum pname, GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY LightModelf(GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY LightModelfv(GLenum pname, const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY LightModelx(GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY LightModelxv(GLenum pname, const GLfixed *param);
+ANGLE_EXPORT void GL_APIENTRY Lightf(GLenum light, GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY Lightfv(GLenum light, GLenum pname, const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY Lightx(GLenum light, GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY Lightxv(GLenum light, GLenum pname, const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY LineWidthx(GLfixed width);
+ANGLE_EXPORT void GL_APIENTRY LoadIdentity();
+ANGLE_EXPORT void GL_APIENTRY LoadMatrixf(const GLfloat *m);
+ANGLE_EXPORT void GL_APIENTRY LoadMatrixx(const GLfixed *m);
+ANGLE_EXPORT void GL_APIENTRY LogicOp(GLenum opcode);
+ANGLE_EXPORT void GL_APIENTRY Materialf(GLenum face, GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY Materialfv(GLenum face, GLenum pname, const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY Materialx(GLenum face, GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY Materialxv(GLenum face, GLenum pname, const GLfixed *param);
+ANGLE_EXPORT void GL_APIENTRY MatrixMode(GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY MultMatrixf(const GLfloat *m);
+ANGLE_EXPORT void GL_APIENTRY MultMatrixx(const GLfixed *m);
+ANGLE_EXPORT void GL_APIENTRY
+MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+ANGLE_EXPORT void GL_APIENTRY
+MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q);
+ANGLE_EXPORT void GL_APIENTRY Normal3f(GLfloat nx, GLfloat ny, GLfloat nz);
+ANGLE_EXPORT void GL_APIENTRY Normal3x(GLfixed nx, GLfixed ny, GLfixed nz);
+ANGLE_EXPORT void GL_APIENTRY NormalPointer(GLenum type, GLsizei stride, const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY
+Orthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f);
+ANGLE_EXPORT void GL_APIENTRY
+Orthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f);
+ANGLE_EXPORT void GL_APIENTRY PointParameterf(GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY PointParameterfv(GLenum pname, const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY PointParameterx(GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY PointParameterxv(GLenum pname, const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY PointSize(GLfloat size);
+ANGLE_EXPORT void GL_APIENTRY PointSizex(GLfixed size);
+ANGLE_EXPORT void GL_APIENTRY PolygonOffsetx(GLfixed factor, GLfixed units);
+ANGLE_EXPORT void GL_APIENTRY PopMatrix();
+ANGLE_EXPORT void GL_APIENTRY PushMatrix();
+ANGLE_EXPORT void GL_APIENTRY Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+ANGLE_EXPORT void GL_APIENTRY Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
+ANGLE_EXPORT void GL_APIENTRY SampleCoveragex(GLclampx value, GLboolean invert);
+ANGLE_EXPORT void GL_APIENTRY Scalef(GLfloat x, GLfloat y, GLfloat z);
+ANGLE_EXPORT void GL_APIENTRY Scalex(GLfixed x, GLfixed y, GLfixed z);
+ANGLE_EXPORT void GL_APIENTRY ShadeModel(GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY TexCoordPointer(GLint size,
+                                              GLenum type,
+                                              GLsizei stride,
+                                              const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY TexEnvf(GLenum target, GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY TexEnvfv(GLenum target, GLenum pname, const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY TexEnvi(GLenum target, GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY TexEnviv(GLenum target, GLenum pname, const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexEnvx(GLenum target, GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY TexEnvxv(GLenum target, GLenum pname, const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterx(GLenum target, GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY TexParameterxv(GLenum target, GLenum pname, const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY Translatef(GLfloat x, GLfloat y, GLfloat z);
+ANGLE_EXPORT void GL_APIENTRY Translatex(GLfixed x, GLfixed y, GLfixed z);
+ANGLE_EXPORT void GL_APIENTRY VertexPointer(GLint size,
+                                            GLenum type,
+                                            GLsizei stride,
+                                            const void *pointer);
+}  // namespace gl
+
+#endif  // LIBGLESV2_ENTRY_POINTS_GLES_1_0_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.cpp
new file mode 100644
index 0000000000..a723a888ca
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.cpp
@@ -0,0 +1,2503 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_2_0_autogen.cpp:
+//   Defines the GLES 2.0 entry points.
+
+#include "libGLESv2/entry_points_gles_2_0_autogen.h"
+
+#include "libANGLE/Context.h"
+#include "libANGLE/Context.inl.h"
+#include "libANGLE/capture_gles_2_0_autogen.h"
+#include "libANGLE/entry_points_utils.h"
+#include "libANGLE/validationES2.h"
+#include "libGLESv2/global_state.h"
+
+namespace gl
+{
+void GL_APIENTRY ActiveTexture(GLenum texture)
+{
+    EVENT("(GLenum texture = 0x%X)", texture);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ActiveTexture, context, texture);
+        if (context->skipValidation() || ValidateActiveTexture(context, texture))
+        {
+            context->activeTexture(texture);
+        }
+    }
+}
+
+void GL_APIENTRY AttachShader(GLuint program, GLuint shader)
+{
+    EVENT("(GLuint program = %u, GLuint shader = %u)", program, shader);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(AttachShader, context, program, shader);
+        if (context->skipValidation() || ValidateAttachShader(context, program, shader))
+        {
+            context->attachShader(program, shader);
+        }
+    }
+}
+
+void GL_APIENTRY BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
+{
+    EVENT("(GLuint program = %u, GLuint index = %u, const GLchar *name = 0x%016" PRIxPTR ")",
+          program, index, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindAttribLocation, context, program, index, name);
+        if (context->skipValidation() || ValidateBindAttribLocation(context, program, index, name))
+        {
+            context->bindAttribLocation(program, index, name);
+        }
+    }
+}
+
+void GL_APIENTRY BindBuffer(GLenum target, GLuint buffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint buffer = %u)", target, buffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(BindBuffer, context, targetPacked, buffer);
+        if (context->skipValidation() || ValidateBindBuffer(context, targetPacked, buffer))
+        {
+            context->bindBuffer(targetPacked, buffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindFramebuffer(GLenum target, GLuint framebuffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint framebuffer = %u)", target, framebuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindFramebuffer, context, target, framebuffer);
+        if (context->skipValidation() || ValidateBindFramebuffer(context, target, framebuffer))
+        {
+            context->bindFramebuffer(target, framebuffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindRenderbuffer(GLenum target, GLuint renderbuffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint renderbuffer = %u)", target, renderbuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindRenderbuffer, context, target, renderbuffer);
+        if (context->skipValidation() || ValidateBindRenderbuffer(context, target, renderbuffer))
+        {
+            context->bindRenderbuffer(target, renderbuffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindTexture(GLenum target, GLuint texture)
+{
+    EVENT("(GLenum target = 0x%X, GLuint texture = %u)", target, texture);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(BindTexture, context, targetPacked, texture);
+        if (context->skipValidation() || ValidateBindTexture(context, targetPacked, texture))
+        {
+            context->bindTexture(targetPacked, texture);
+        }
+    }
+}
+
+void GL_APIENTRY BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
+          green, blue, alpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BlendColor, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateBlendColor(context, red, green, blue, alpha))
+        {
+            context->blendColor(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY BlendEquation(GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BlendEquation, context, mode);
+        if (context->skipValidation() || ValidateBlendEquation(context, mode))
+        {
+            context->blendEquation(mode);
+        }
+    }
+}
+
+void GL_APIENTRY BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+{
+    EVENT("(GLenum modeRGB = 0x%X, GLenum modeAlpha = 0x%X)", modeRGB, modeAlpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BlendEquationSeparate, context, modeRGB, modeAlpha);
+        if (context->skipValidation() || ValidateBlendEquationSeparate(context, modeRGB, modeAlpha))
+        {
+            context->blendEquationSeparate(modeRGB, modeAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY BlendFunc(GLenum sfactor, GLenum dfactor)
+{
+    EVENT("(GLenum sfactor = 0x%X, GLenum dfactor = 0x%X)", sfactor, dfactor);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BlendFunc, context, sfactor, dfactor);
+        if (context->skipValidation() || ValidateBlendFunc(context, sfactor, dfactor))
+        {
+            context->blendFunc(sfactor, dfactor);
+        }
+    }
+}
+
+void GL_APIENTRY BlendFuncSeparate(GLenum sfactorRGB,
+                                   GLenum dfactorRGB,
+                                   GLenum sfactorAlpha,
+                                   GLenum dfactorAlpha)
+{
+    EVENT(
+        "(GLenum sfactorRGB = 0x%X, GLenum dfactorRGB = 0x%X, GLenum sfactorAlpha = 0x%X, GLenum "
+        "dfactorAlpha = 0x%X)",
+        sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BlendFuncSeparate, context, sfactorRGB, dfactorRGB, sfactorAlpha,
+                      dfactorAlpha);
+        if (context->skipValidation() ||
+            ValidateBlendFuncSeparate(context, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha))
+        {
+            context->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY BufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
+{
+    EVENT("(GLenum target = 0x%X, GLsizeiptr size = %llu, const void *data = 0x%016" PRIxPTR
+          ", GLenum usage = 0x%X)",
+          target, static_cast<unsigned long long>(size), (uintptr_t)data, usage);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        BufferUsage usagePacked    = FromGLenum<BufferUsage>(usage);
+        ANGLE_CAPTURE(BufferData, context, targetPacked, size, data, usagePacked);
+        if (context->skipValidation() ||
+            ValidateBufferData(context, targetPacked, size, data, usagePacked))
+        {
+            context->bufferData(targetPacked, size, data, usagePacked);
+        }
+    }
+}
+
+void GL_APIENTRY BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr size = %llu, const void *data = "
+        "0x%016" PRIxPTR ")",
+        target, static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
+        (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(BufferSubData, context, targetPacked, offset, size, data);
+        if (context->skipValidation() ||
+            ValidateBufferSubData(context, targetPacked, offset, size, data))
+        {
+            context->bufferSubData(targetPacked, offset, size, data);
+        }
+    }
+}
+
+GLenum GL_APIENTRY CheckFramebufferStatus(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CheckFramebufferStatus, context, target);
+        if (context->skipValidation() || ValidateCheckFramebufferStatus(context, target))
+        {
+            return context->checkFramebufferStatus(target);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CheckFramebufferStatus, GLenum>();
+}
+
+void GL_APIENTRY Clear(GLbitfield mask)
+{
+    EVENT("(GLbitfield mask = 0x%X)", mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Clear, context, mask);
+        if (context->skipValidation() || ValidateClear(context, mask))
+        {
+            context->clear(mask);
+        }
+    }
+}
+
+void GL_APIENTRY ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
+          green, blue, alpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearColor, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateClearColor(context, red, green, blue, alpha))
+        {
+            context->clearColor(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY ClearDepthf(GLfloat d)
+{
+    EVENT("(GLfloat d = %f)", d);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearDepthf, context, d);
+        if (context->skipValidation() || ValidateClearDepthf(context, d))
+        {
+            context->clearDepthf(d);
+        }
+    }
+}
+
+void GL_APIENTRY ClearStencil(GLint s)
+{
+    EVENT("(GLint s = %d)", s);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearStencil, context, s);
+        if (context->skipValidation() || ValidateClearStencil(context, s))
+        {
+            context->clearStencil(s);
+        }
+    }
+}
+
+void GL_APIENTRY ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+    EVENT("(GLboolean red = %u, GLboolean green = %u, GLboolean blue = %u, GLboolean alpha = %u)",
+          red, green, blue, alpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ColorMask, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateColorMask(context, red, green, blue, alpha))
+        {
+            context->colorMask(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY CompileShader(GLuint shader)
+{
+    EVENT("(GLuint shader = %u)", shader);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CompileShader, context, shader);
+        if (context->skipValidation() || ValidateCompileShader(context, shader))
+        {
+            context->compileShader(shader);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexImage2D(GLenum target,
+                                      GLint level,
+                                      GLenum internalformat,
+                                      GLsizei width,
+                                      GLsizei height,
+                                      GLint border,
+                                      GLsizei imageSize,
+                                      const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const void *data = "
+        "0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, border, imageSize, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage2D, context, targetPacked, level, internalformat, width,
+                      height, border, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexImage2D(context, targetPacked, level, internalformat, width,
+                                         height, border, imageSize, data))
+        {
+            context->compressedTexImage2D(targetPacked, level, internalformat, width, height,
+                                          border, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage2D(GLenum target,
+                                         GLint level,
+                                         GLint xoffset,
+                                         GLint yoffset,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLenum format,
+                                         GLsizei imageSize,
+                                         const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei "
+        "width = %d, GLsizei height = %d, GLenum format = 0x%X, GLsizei imageSize = %d, const void "
+        "*data = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, width, height, format, imageSize, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage2D, context, targetPacked, level, xoffset, yoffset,
+                      width, height, format, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexSubImage2D(context, targetPacked, level, xoffset, yoffset, width,
+                                            height, format, imageSize, data))
+        {
+            context->compressedTexSubImage2D(targetPacked, level, xoffset, yoffset, width, height,
+                                             format, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexImage2D(GLenum target,
+                                GLint level,
+                                GLenum internalformat,
+                                GLint x,
+                                GLint y,
+                                GLsizei width,
+                                GLsizei height,
+                                GLint border)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLint x = %d, "
+        "GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d)",
+        target, level, internalformat, x, y, width, height, border);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CopyTexImage2D, context, targetPacked, level, internalformat, x, y, width,
+                      height, border);
+        if (context->skipValidation() ||
+            ValidateCopyTexImage2D(context, targetPacked, level, internalformat, x, y, width,
+                                   height, border))
+        {
+            context->copyTexImage2D(targetPacked, level, internalformat, x, y, width, height,
+                                    border);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexSubImage2D(GLenum target,
+                                   GLint level,
+                                   GLint xoffset,
+                                   GLint yoffset,
+                                   GLint x,
+                                   GLint y,
+                                   GLsizei width,
+                                   GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint x "
+        "= %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+        target, level, xoffset, yoffset, x, y, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CopyTexSubImage2D, context, targetPacked, level, xoffset, yoffset, x, y,
+                      width, height);
+        if (context->skipValidation() ||
+            ValidateCopyTexSubImage2D(context, targetPacked, level, xoffset, yoffset, x, y, width,
+                                      height))
+        {
+            context->copyTexSubImage2D(targetPacked, level, xoffset, yoffset, x, y, width, height);
+        }
+    }
+}
+
+GLuint GL_APIENTRY CreateProgram()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CreateProgram, context);
+        if (context->skipValidation() || ValidateCreateProgram(context))
+        {
+            return context->createProgram();
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CreateProgram, GLuint>();
+}
+
+GLuint GL_APIENTRY CreateShader(GLenum type)
+{
+    EVENT("(GLenum type = 0x%X)", type);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ShaderType typePacked = FromGLenum<ShaderType>(type);
+        ANGLE_CAPTURE(CreateShader, context, typePacked);
+        if (context->skipValidation() || ValidateCreateShader(context, typePacked))
+        {
+            return context->createShader(typePacked);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CreateShader, GLuint>();
+}
+
+void GL_APIENTRY CullFace(GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        CullFaceMode modePacked = FromGLenum<CullFaceMode>(mode);
+        ANGLE_CAPTURE(CullFace, context, modePacked);
+        if (context->skipValidation() || ValidateCullFace(context, modePacked))
+        {
+            context->cullFace(modePacked);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteBuffers(GLsizei n, const GLuint *buffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *buffers = 0x%016" PRIxPTR ")", n, (uintptr_t)buffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteBuffers, context, n, buffers);
+        if (context->skipValidation() || ValidateDeleteBuffers(context, n, buffers))
+        {
+            context->deleteBuffers(n, buffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *framebuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)framebuffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteFramebuffers, context, n, framebuffers);
+        if (context->skipValidation() || ValidateDeleteFramebuffers(context, n, framebuffers))
+        {
+            context->deleteFramebuffers(n, framebuffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteProgram(GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteProgram, context, program);
+        if (context->skipValidation() || ValidateDeleteProgram(context, program))
+        {
+            context->deleteProgram(program);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *renderbuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)renderbuffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteRenderbuffers, context, n, renderbuffers);
+        if (context->skipValidation() || ValidateDeleteRenderbuffers(context, n, renderbuffers))
+        {
+            context->deleteRenderbuffers(n, renderbuffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteShader(GLuint shader)
+{
+    EVENT("(GLuint shader = %u)", shader);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteShader, context, shader);
+        if (context->skipValidation() || ValidateDeleteShader(context, shader))
+        {
+            context->deleteShader(shader);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteTextures(GLsizei n, const GLuint *textures)
+{
+    EVENT("(GLsizei n = %d, const GLuint *textures = 0x%016" PRIxPTR ")", n, (uintptr_t)textures);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteTextures, context, n, textures);
+        if (context->skipValidation() || ValidateDeleteTextures(context, n, textures))
+        {
+            context->deleteTextures(n, textures);
+        }
+    }
+}
+
+void GL_APIENTRY DepthFunc(GLenum func)
+{
+    EVENT("(GLenum func = 0x%X)", func);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DepthFunc, context, func);
+        if (context->skipValidation() || ValidateDepthFunc(context, func))
+        {
+            context->depthFunc(func);
+        }
+    }
+}
+
+void GL_APIENTRY DepthMask(GLboolean flag)
+{
+    EVENT("(GLboolean flag = %u)", flag);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DepthMask, context, flag);
+        if (context->skipValidation() || ValidateDepthMask(context, flag))
+        {
+            context->depthMask(flag);
+        }
+    }
+}
+
+void GL_APIENTRY DepthRangef(GLfloat n, GLfloat f)
+{
+    EVENT("(GLfloat n = %f, GLfloat f = %f)", n, f);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DepthRangef, context, n, f);
+        if (context->skipValidation() || ValidateDepthRangef(context, n, f))
+        {
+            context->depthRangef(n, f);
+        }
+    }
+}
+
+void GL_APIENTRY DetachShader(GLuint program, GLuint shader)
+{
+    EVENT("(GLuint program = %u, GLuint shader = %u)", program, shader);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DetachShader, context, program, shader);
+        if (context->skipValidation() || ValidateDetachShader(context, program, shader))
+        {
+            context->detachShader(program, shader);
+        }
+    }
+}
+
+void GL_APIENTRY Disable(GLenum cap)
+{
+    EVENT("(GLenum cap = 0x%X)", cap);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Disable, context, cap);
+        if (context->skipValidation() || ValidateDisable(context, cap))
+        {
+            context->disable(cap);
+        }
+    }
+}
+
+void GL_APIENTRY DisableVertexAttribArray(GLuint index)
+{
+    EVENT("(GLuint index = %u)", index);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DisableVertexAttribArray, context, index);
+        if (context->skipValidation() || ValidateDisableVertexAttribArray(context, index))
+        {
+            context->disableVertexAttribArray(index);
+        }
+    }
+}
+
+void GL_APIENTRY DrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+    EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d)", mode, first, count);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArrays, context, modePacked, first, count);
+        if (context->skipValidation() || ValidateDrawArrays(context, modePacked, first, count))
+        {
+            context->drawArrays(modePacked, first, count);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = "
+        "0x%016" PRIxPTR ")",
+        mode, count, type, (uintptr_t)indices);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElements, context, modePacked, count, typePacked, indices);
+        if (context->skipValidation() ||
+            ValidateDrawElements(context, modePacked, count, typePacked, indices))
+        {
+            context->drawElements(modePacked, count, typePacked, indices);
+        }
+    }
+}
+
+void GL_APIENTRY Enable(GLenum cap)
+{
+    EVENT("(GLenum cap = 0x%X)", cap);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Enable, context, cap);
+        if (context->skipValidation() || ValidateEnable(context, cap))
+        {
+            context->enable(cap);
+        }
+    }
+}
+
+void GL_APIENTRY EnableVertexAttribArray(GLuint index)
+{
+    EVENT("(GLuint index = %u)", index);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(EnableVertexAttribArray, context, index);
+        if (context->skipValidation() || ValidateEnableVertexAttribArray(context, index))
+        {
+            context->enableVertexAttribArray(index);
+        }
+    }
+}
+
+void GL_APIENTRY Finish()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Finish, context);
+        if (context->skipValidation() || ValidateFinish(context))
+        {
+            context->finish();
+        }
+    }
+}
+
+void GL_APIENTRY Flush()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Flush, context);
+        if (context->skipValidation() || ValidateFlush(context))
+        {
+            context->flush();
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferRenderbuffer(GLenum target,
+                                         GLenum attachment,
+                                         GLenum renderbuffertarget,
+                                         GLuint renderbuffer)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, GLuint "
+        "renderbuffer = %u)",
+        target, attachment, renderbuffertarget, renderbuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FramebufferRenderbuffer, context, target, attachment, renderbuffertarget,
+                      renderbuffer);
+        if (context->skipValidation() ||
+            ValidateFramebufferRenderbuffer(context, target, attachment, renderbuffertarget,
+                                            renderbuffer))
+        {
+            context->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTexture2D(GLenum target,
+                                      GLenum attachment,
+                                      GLenum textarget,
+                                      GLuint texture,
+                                      GLint level)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, GLuint texture "
+        "= %u, GLint level = %d)",
+        target, attachment, textarget, texture, level);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget textargetPacked = FromGLenum<TextureTarget>(textarget);
+        ANGLE_CAPTURE(FramebufferTexture2D, context, target, attachment, textargetPacked, texture,
+                      level);
+        if (context->skipValidation() ||
+            ValidateFramebufferTexture2D(context, target, attachment, textargetPacked, texture,
+                                         level))
+        {
+            context->framebufferTexture2D(target, attachment, textargetPacked, texture, level);
+        }
+    }
+}
+
+void GL_APIENTRY FrontFace(GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FrontFace, context, mode);
+        if (context->skipValidation() || ValidateFrontFace(context, mode))
+        {
+            context->frontFace(mode);
+        }
+    }
+}
+
+void GL_APIENTRY GenBuffers(GLsizei n, GLuint *buffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *buffers = 0x%016" PRIxPTR ")", n, (uintptr_t)buffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenBuffers, context, n, buffers);
+        if (context->skipValidation() || ValidateGenBuffers(context, n, buffers))
+        {
+            context->genBuffers(n, buffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenFramebuffers(GLsizei n, GLuint *framebuffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *framebuffers = 0x%016" PRIxPTR ")", n, (uintptr_t)framebuffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenFramebuffers, context, n, framebuffers);
+        if (context->skipValidation() || ValidateGenFramebuffers(context, n, framebuffers))
+        {
+            context->genFramebuffers(n, framebuffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenRenderbuffers(GLsizei n, GLuint *renderbuffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *renderbuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)renderbuffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenRenderbuffers, context, n, renderbuffers);
+        if (context->skipValidation() || ValidateGenRenderbuffers(context, n, renderbuffers))
+        {
+            context->genRenderbuffers(n, renderbuffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenTextures(GLsizei n, GLuint *textures)
+{
+    EVENT("(GLsizei n = %d, GLuint *textures = 0x%016" PRIxPTR ")", n, (uintptr_t)textures);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenTextures, context, n, textures);
+        if (context->skipValidation() || ValidateGenTextures(context, n, textures))
+        {
+            context->genTextures(n, textures);
+        }
+    }
+}
+
+void GL_APIENTRY GenerateMipmap(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GenerateMipmap, context, targetPacked);
+        if (context->skipValidation() || ValidateGenerateMipmap(context, targetPacked))
+        {
+            context->generateMipmap(targetPacked);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveAttrib(GLuint program,
+                                 GLuint index,
+                                 GLsizei bufSize,
+                                 GLsizei *length,
+                                 GLint *size,
+                                 GLenum *type,
+                                 GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei *length = "
+        "0x%016" PRIxPTR ", GLint *size = 0x%016" PRIxPTR ", GLenum *type = 0x%016" PRIxPTR
+        ", GLchar *name = 0x%016" PRIxPTR ")",
+        program, index, bufSize, (uintptr_t)length, (uintptr_t)size, (uintptr_t)type,
+        (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetActiveAttrib, context, program, index, bufSize, length, size, type, name);
+        if (context->skipValidation() ||
+            ValidateGetActiveAttrib(context, program, index, bufSize, length, size, type, name))
+        {
+            context->getActiveAttrib(program, index, bufSize, length, size, type, name);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniform(GLuint program,
+                                  GLuint index,
+                                  GLsizei bufSize,
+                                  GLsizei *length,
+                                  GLint *size,
+                                  GLenum *type,
+                                  GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei *length = "
+        "0x%016" PRIxPTR ", GLint *size = 0x%016" PRIxPTR ", GLenum *type = 0x%016" PRIxPTR
+        ", GLchar *name = 0x%016" PRIxPTR ")",
+        program, index, bufSize, (uintptr_t)length, (uintptr_t)size, (uintptr_t)type,
+        (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetActiveUniform, context, program, index, bufSize, length, size, type, name);
+        if (context->skipValidation() ||
+            ValidateGetActiveUniform(context, program, index, bufSize, length, size, type, name))
+        {
+            context->getActiveUniform(program, index, bufSize, length, size, type, name);
+        }
+    }
+}
+
+void GL_APIENTRY GetAttachedShaders(GLuint program,
+                                    GLsizei maxCount,
+                                    GLsizei *count,
+                                    GLuint *shaders)
+{
+    EVENT("(GLuint program = %u, GLsizei maxCount = %d, GLsizei *count = 0x%016" PRIxPTR
+          ", GLuint *shaders = 0x%016" PRIxPTR ")",
+          program, maxCount, (uintptr_t)count, (uintptr_t)shaders);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetAttachedShaders, context, program, maxCount, count, shaders);
+        if (context->skipValidation() ||
+            ValidateGetAttachedShaders(context, program, maxCount, count, shaders))
+        {
+            context->getAttachedShaders(program, maxCount, count, shaders);
+        }
+    }
+}
+
+GLint GL_APIENTRY GetAttribLocation(GLuint program, const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetAttribLocation, context, program, name);
+        if (context->skipValidation() || ValidateGetAttribLocation(context, program, name))
+        {
+            return context->getAttribLocation(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetAttribLocation, GLint>();
+}
+
+void GL_APIENTRY GetBooleanv(GLenum pname, GLboolean *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLboolean *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetBooleanv, context, pname, data);
+        if (context->skipValidation() || ValidateGetBooleanv(context, pname, data))
+        {
+            context->getBooleanv(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferParameteriv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetBufferParameteriv(context, targetPacked, pname, params))
+        {
+            context->getBufferParameteriv(targetPacked, pname, params);
+        }
+    }
+}
+
+GLenum GL_APIENTRY GetError()
+{
+    EVENT("()");
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetError, context);
+        if (context->skipValidation() || ValidateGetError(context))
+        {
+            return context->getError();
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetError, GLenum>();
+}
+
+void GL_APIENTRY GetFloatv(GLenum pname, GLfloat *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLfloat *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFloatv, context, pname, data);
+        if (context->skipValidation() || ValidateGetFloatv(context, pname, data))
+        {
+            context->getFloatv(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target,
+                                                     GLenum attachment,
+                                                     GLenum pname,
+                                                     GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        target, attachment, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFramebufferAttachmentParameteriv, context, target, attachment, pname,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetFramebufferAttachmentParameteriv(context, target, attachment, pname, params))
+        {
+            context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetIntegerv(GLenum pname, GLint *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLint *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetIntegerv, context, pname, data);
+        if (context->skipValidation() || ValidateGetIntegerv(context, pname, data))
+        {
+            context->getIntegerv(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramInfoLog(GLuint program,
+                                   GLsizei bufSize,
+                                   GLsizei *length,
+                                   GLchar *infoLog)
+{
+    EVENT("(GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *infoLog = 0x%016" PRIxPTR ")",
+          program, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramInfoLog, context, program, bufSize, length, infoLog);
+        if (context->skipValidation() ||
+            ValidateGetProgramInfoLog(context, program, bufSize, length, infoLog))
+        {
+            context->getProgramInfoLog(program, bufSize, length, infoLog);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint program = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", program,
+          pname, (uintptr_t)params);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramiv, context, program, pname, params);
+        if (context->skipValidation() || ValidateGetProgramiv(context, program, pname, params))
+        {
+            context->getProgramiv(program, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetRenderbufferParameteriv, context, target, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetRenderbufferParameteriv(context, target, pname, params))
+        {
+            context->getRenderbufferParameteriv(target, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
+{
+    EVENT("(GLuint shader = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *infoLog = 0x%016" PRIxPTR ")",
+          shader, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetShaderInfoLog, context, shader, bufSize, length, infoLog);
+        if (context->skipValidation() ||
+            ValidateGetShaderInfoLog(context, shader, bufSize, length, infoLog))
+        {
+            context->getShaderInfoLog(shader, bufSize, length, infoLog);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderPrecisionFormat(GLenum shadertype,
+                                          GLenum precisiontype,
+                                          GLint *range,
+                                          GLint *precision)
+{
+    EVENT("(GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint *range = 0x%016" PRIxPTR
+          ", GLint *precision = 0x%016" PRIxPTR ")",
+          shadertype, precisiontype, (uintptr_t)range, (uintptr_t)precision);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetShaderPrecisionFormat, context, shadertype, precisiontype, range,
+                      precision);
+        if (context->skipValidation() ||
+            ValidateGetShaderPrecisionFormat(context, shadertype, precisiontype, range, precision))
+        {
+            context->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
+{
+    EVENT("(GLuint shader = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *source = 0x%016" PRIxPTR ")",
+          shader, bufSize, (uintptr_t)length, (uintptr_t)source);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetShaderSource, context, shader, bufSize, length, source);
+        if (context->skipValidation() ||
+            ValidateGetShaderSource(context, shader, bufSize, length, source))
+        {
+            context->getShaderSource(shader, bufSize, length, source);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint shader = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", shader,
+          pname, (uintptr_t)params);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetShaderiv, context, shader, pname, params);
+        if (context->skipValidation() || ValidateGetShaderiv(context, shader, pname, params))
+        {
+            context->getShaderiv(shader, pname, params);
+        }
+    }
+}
+
+const GLubyte *GL_APIENTRY GetString(GLenum name)
+{
+    EVENT("(GLenum name = 0x%X)", name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetString, context, name);
+        if (context->skipValidation() || ValidateGetString(context, name))
+        {
+            return context->getString(name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetString, const GLubyte *>();
+}
+
+void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterfv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameterfv(context, targetPacked, pname, params))
+        {
+            context->getTexParameterfv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameteriv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameteriv(context, targetPacked, pname, params))
+        {
+            context->getTexParameteriv(targetPacked, pname, params);
+        }
+    }
+}
+
+GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformLocation, context, program, name);
+        if (context->skipValidation() || ValidateGetUniformLocation(context, program, name))
+        {
+            return context->getUniformLocation(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetUniformLocation, GLint>();
+}
+
+void GL_APIENTRY GetUniformfv(GLuint program, GLint location, GLfloat *params)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLfloat *params = 0x%016" PRIxPTR ")",
+          program, location, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformfv, context, program, location, params);
+        if (context->skipValidation() || ValidateGetUniformfv(context, program, location, params))
+        {
+            context->getUniformfv(program, location, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformiv(GLuint program, GLint location, GLint *params)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLint *params = 0x%016" PRIxPTR ")", program,
+          location, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformiv, context, program, location, params);
+        if (context->skipValidation() || ValidateGetUniformiv(context, program, location, params))
+        {
+            context->getUniformiv(program, location, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, void **pointer = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribPointerv, context, index, pname, pointer);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribPointerv(context, index, pname, pointer))
+        {
+            context->getVertexAttribPointerv(index, pname, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribfv, context, index, pname, params);
+        if (context->skipValidation() || ValidateGetVertexAttribfv(context, index, pname, params))
+        {
+            context->getVertexAttribfv(index, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribiv, context, index, pname, params);
+        if (context->skipValidation() || ValidateGetVertexAttribiv(context, index, pname, params))
+        {
+            context->getVertexAttribiv(index, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY Hint(GLenum target, GLenum mode)
+{
+    EVENT("(GLenum target = 0x%X, GLenum mode = 0x%X)", target, mode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Hint, context, target, mode);
+        if (context->skipValidation() || ValidateHint(context, target, mode))
+        {
+            context->hint(target, mode);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsBuffer(GLuint buffer)
+{
+    EVENT("(GLuint buffer = %u)", buffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsBuffer, context, buffer);
+        if (context->skipValidation() || ValidateIsBuffer(context, buffer))
+        {
+            return context->isBuffer(buffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsBuffer, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsEnabled(GLenum cap)
+{
+    EVENT("(GLenum cap = 0x%X)", cap);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsEnabled, context, cap);
+        if (context->skipValidation() || ValidateIsEnabled(context, cap))
+        {
+            return context->isEnabled(cap);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsEnabled, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsFramebuffer(GLuint framebuffer)
+{
+    EVENT("(GLuint framebuffer = %u)", framebuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsFramebuffer, context, framebuffer);
+        if (context->skipValidation() || ValidateIsFramebuffer(context, framebuffer))
+        {
+            return context->isFramebuffer(framebuffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsFramebuffer, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsProgram(GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsProgram, context, program);
+        if (context->skipValidation() || ValidateIsProgram(context, program))
+        {
+            return context->isProgram(program);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsProgram, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsRenderbuffer(GLuint renderbuffer)
+{
+    EVENT("(GLuint renderbuffer = %u)", renderbuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsRenderbuffer, context, renderbuffer);
+        if (context->skipValidation() || ValidateIsRenderbuffer(context, renderbuffer))
+        {
+            return context->isRenderbuffer(renderbuffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsRenderbuffer, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsShader(GLuint shader)
+{
+    EVENT("(GLuint shader = %u)", shader);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsShader, context, shader);
+        if (context->skipValidation() || ValidateIsShader(context, shader))
+        {
+            return context->isShader(shader);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsShader, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsTexture(GLuint texture)
+{
+    EVENT("(GLuint texture = %u)", texture);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsTexture, context, texture);
+        if (context->skipValidation() || ValidateIsTexture(context, texture))
+        {
+            return context->isTexture(texture);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsTexture, GLboolean>();
+}
+
+void GL_APIENTRY LineWidth(GLfloat width)
+{
+    EVENT("(GLfloat width = %f)", width);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LineWidth, context, width);
+        if (context->skipValidation() || ValidateLineWidth(context, width))
+        {
+            context->lineWidth(width);
+        }
+    }
+}
+
+void GL_APIENTRY LinkProgram(GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LinkProgram, context, program);
+        if (context->skipValidation() || ValidateLinkProgram(context, program))
+        {
+            context->linkProgram(program);
+        }
+    }
+}
+
+void GL_APIENTRY PixelStorei(GLenum pname, GLint param)
+{
+    EVENT("(GLenum pname = 0x%X, GLint param = %d)", pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PixelStorei, context, pname, param);
+        if (context->skipValidation() || ValidatePixelStorei(context, pname, param))
+        {
+            context->pixelStorei(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY PolygonOffset(GLfloat factor, GLfloat units)
+{
+    EVENT("(GLfloat factor = %f, GLfloat units = %f)", factor, units);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PolygonOffset, context, factor, units);
+        if (context->skipValidation() || ValidatePolygonOffset(context, factor, units))
+        {
+            context->polygonOffset(factor, units);
+        }
+    }
+}
+
+void GL_APIENTRY ReadPixels(GLint x,
+                            GLint y,
+                            GLsizei width,
+                            GLsizei height,
+                            GLenum format,
+                            GLenum type,
+                            void *pixels)
+{
+    EVENT(
+        "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = "
+        "0x%X, GLenum type = 0x%X, void *pixels = 0x%016" PRIxPTR ")",
+        x, y, width, height, format, type, (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ReadPixels, context, x, y, width, height, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateReadPixels(context, x, y, width, height, format, type, pixels))
+        {
+            context->readPixels(x, y, width, height, format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY ReleaseShaderCompiler()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ReleaseShaderCompiler, context);
+        if (context->skipValidation() || ValidateReleaseShaderCompiler(context))
+        {
+            context->releaseShaderCompiler();
+        }
+    }
+}
+
+void GL_APIENTRY RenderbufferStorage(GLenum target,
+                                     GLenum internalformat,
+                                     GLsizei width,
+                                     GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = "
+        "%d)",
+        target, internalformat, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(RenderbufferStorage, context, target, internalformat, width, height);
+        if (context->skipValidation() ||
+            ValidateRenderbufferStorage(context, target, internalformat, width, height))
+        {
+            context->renderbufferStorage(target, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY SampleCoverage(GLfloat value, GLboolean invert)
+{
+    EVENT("(GLfloat value = %f, GLboolean invert = %u)", value, invert);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SampleCoverage, context, value, invert);
+        if (context->skipValidation() || ValidateSampleCoverage(context, value, invert))
+        {
+            context->sampleCoverage(value, invert);
+        }
+    }
+}
+
+void GL_APIENTRY Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width,
+          height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Scissor, context, x, y, width, height);
+        if (context->skipValidation() || ValidateScissor(context, x, y, width, height))
+        {
+            context->scissor(x, y, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY ShaderBinary(GLsizei count,
+                              const GLuint *shaders,
+                              GLenum binaryformat,
+                              const void *binary,
+                              GLsizei length)
+{
+    EVENT("(GLsizei count = %d, const GLuint *shaders = 0x%016" PRIxPTR
+          ", GLenum binaryformat = 0x%X, const void *binary = 0x%016" PRIxPTR
+          ", GLsizei length = %d)",
+          count, (uintptr_t)shaders, binaryformat, (uintptr_t)binary, length);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ShaderBinary, context, count, shaders, binaryformat, binary, length);
+        if (context->skipValidation() ||
+            ValidateShaderBinary(context, count, shaders, binaryformat, binary, length))
+        {
+            context->shaderBinary(count, shaders, binaryformat, binary, length);
+        }
+    }
+}
+
+void GL_APIENTRY ShaderSource(GLuint shader,
+                              GLsizei count,
+                              const GLchar *const *string,
+                              const GLint *length)
+{
+    EVENT("(GLuint shader = %u, GLsizei count = %d, const GLchar *const*string = 0x%016" PRIxPTR
+          ", const GLint *length = 0x%016" PRIxPTR ")",
+          shader, count, (uintptr_t)string, (uintptr_t)length);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ShaderSource, context, shader, count, string, length);
+        if (context->skipValidation() ||
+            ValidateShaderSource(context, shader, count, string, length))
+        {
+            context->shaderSource(shader, count, string, length);
+        }
+    }
+}
+
+void GL_APIENTRY StencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+    EVENT("(GLenum func = 0x%X, GLint ref = %d, GLuint mask = %u)", func, ref, mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilFunc, context, func, ref, mask);
+        if (context->skipValidation() || ValidateStencilFunc(context, func, ref, mask))
+        {
+            context->stencilFunc(func, ref, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+{
+    EVENT("(GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %u)", face, func,
+          ref, mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilFuncSeparate, context, face, func, ref, mask);
+        if (context->skipValidation() ||
+            ValidateStencilFuncSeparate(context, face, func, ref, mask))
+        {
+            context->stencilFuncSeparate(face, func, ref, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilMask(GLuint mask)
+{
+    EVENT("(GLuint mask = %u)", mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilMask, context, mask);
+        if (context->skipValidation() || ValidateStencilMask(context, mask))
+        {
+            context->stencilMask(mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilMaskSeparate(GLenum face, GLuint mask)
+{
+    EVENT("(GLenum face = 0x%X, GLuint mask = %u)", face, mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilMaskSeparate, context, face, mask);
+        if (context->skipValidation() || ValidateStencilMaskSeparate(context, face, mask))
+        {
+            context->stencilMaskSeparate(face, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+    EVENT("(GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpass = 0x%X)", fail, zfail, zpass);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilOp, context, fail, zfail, zpass);
+        if (context->skipValidation() || ValidateStencilOp(context, fail, zfail, zpass))
+        {
+            context->stencilOp(fail, zfail, zpass);
+        }
+    }
+}
+
+void GL_APIENTRY StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
+{
+    EVENT("(GLenum face = 0x%X, GLenum sfail = 0x%X, GLenum dpfail = 0x%X, GLenum dppass = 0x%X)",
+          face, sfail, dpfail, dppass);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilOpSeparate, context, face, sfail, dpfail, dppass);
+        if (context->skipValidation() ||
+            ValidateStencilOpSeparate(context, face, sfail, dpfail, dppass))
+        {
+            context->stencilOpSeparate(face, sfail, dpfail, dppass);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage2D(GLenum target,
+                            GLint level,
+                            GLint internalformat,
+                            GLsizei width,
+                            GLsizei height,
+                            GLint border,
+                            GLenum format,
+                            GLenum type,
+                            const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const "
+        "void *pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, border, format, type, (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage2D, context, targetPacked, level, internalformat, width, height,
+                      border, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage2D(context, targetPacked, level, internalformat, width, height, border,
+                               format, type, pixels))
+        {
+            context->texImage2D(targetPacked, level, internalformat, width, height, border, format,
+                                type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", target, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterf, context, targetPacked, pname, param);
+        if (context->skipValidation() || ValidateTexParameterf(context, targetPacked, pname, param))
+        {
+            context->texParameterf(targetPacked, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterfv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterfv(context, targetPacked, pname, params))
+        {
+            context->texParameterfv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameteri(GLenum target, GLenum pname, GLint param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameteri, context, targetPacked, pname, param);
+        if (context->skipValidation() || ValidateTexParameteri(context, targetPacked, pname, param))
+        {
+            context->texParameteri(targetPacked, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameteriv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameteriv(context, targetPacked, pname, params))
+        {
+            context->texParameteriv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage2D(GLenum target,
+                               GLint level,
+                               GLint xoffset,
+                               GLint yoffset,
+                               GLsizei width,
+                               GLsizei height,
+                               GLenum format,
+                               GLenum type,
+                               const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei "
+        "width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, const void "
+        "*pixels = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, width, height, format, type, (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage2D, context, targetPacked, level, xoffset, yoffset, width, height,
+                      format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage2D(context, targetPacked, level, xoffset, yoffset, width, height,
+                                  format, type, pixels))
+        {
+            context->texSubImage2D(targetPacked, level, xoffset, yoffset, width, height, format,
+                                   type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1f(GLint location, GLfloat v0)
+{
+    EVENT("(GLint location = %d, GLfloat v0 = %f)", location, v0);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform1f, context, location, v0);
+        if (context->skipValidation() || ValidateUniform1f(context, location, v0))
+        {
+            context->uniform1f(location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform1fv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform1fv(context, location, count, value))
+        {
+            context->uniform1fv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1i(GLint location, GLint v0)
+{
+    EVENT("(GLint location = %d, GLint v0 = %d)", location, v0);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform1i, context, location, v0);
+        if (context->skipValidation() || ValidateUniform1i(context, location, v0))
+        {
+            context->uniform1i(location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1iv(GLint location, GLsizei count, const GLint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform1iv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform1iv(context, location, count, value))
+        {
+            context->uniform1iv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2f(GLint location, GLfloat v0, GLfloat v1)
+{
+    EVENT("(GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f)", location, v0, v1);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform2f, context, location, v0, v1);
+        if (context->skipValidation() || ValidateUniform2f(context, location, v0, v1))
+        {
+            context->uniform2f(location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform2fv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform2fv(context, location, count, value))
+        {
+            context->uniform2fv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2i(GLint location, GLint v0, GLint v1)
+{
+    EVENT("(GLint location = %d, GLint v0 = %d, GLint v1 = %d)", location, v0, v1);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform2i, context, location, v0, v1);
+        if (context->skipValidation() || ValidateUniform2i(context, location, v0, v1))
+        {
+            context->uniform2i(location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2iv(GLint location, GLsizei count, const GLint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform2iv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform2iv(context, location, count, value))
+        {
+            context->uniform2iv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+{
+    EVENT("(GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = %f)", location, v0,
+          v1, v2);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform3f, context, location, v0, v1, v2);
+        if (context->skipValidation() || ValidateUniform3f(context, location, v0, v1, v2))
+        {
+            context->uniform3f(location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform3fv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform3fv(context, location, count, value))
+        {
+            context->uniform3fv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
+{
+    EVENT("(GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d)", location, v0, v1,
+          v2);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform3i, context, location, v0, v1, v2);
+        if (context->skipValidation() || ValidateUniform3i(context, location, v0, v1, v2))
+        {
+            context->uniform3i(location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3iv(GLint location, GLsizei count, const GLint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform3iv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform3iv(context, location, count, value))
+        {
+            context->uniform3iv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+{
+    EVENT(
+        "(GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = %f, GLfloat v3 = %f)",
+        location, v0, v1, v2, v3);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform4f, context, location, v0, v1, v2, v3);
+        if (context->skipValidation() || ValidateUniform4f(context, location, v0, v1, v2, v3))
+        {
+            context->uniform4f(location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform4fv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform4fv(context, location, count, value))
+        {
+            context->uniform4fv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+{
+    EVENT("(GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, GLint v3 = %d)",
+          location, v0, v1, v2, v3);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform4i, context, location, v0, v1, v2, v3);
+        if (context->skipValidation() || ValidateUniform4i(context, location, v0, v1, v2, v3))
+        {
+            context->uniform4i(location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4iv(GLint location, GLsizei count, const GLint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform4iv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform4iv(context, location, count, value))
+        {
+            context->uniform4iv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix2fv(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix2fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix2fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix2fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix3fv(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix3fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix3fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix3fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix4fv(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix4fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix4fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix4fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UseProgram(GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UseProgram, context, program);
+        if (context->skipValidation() || ValidateUseProgram(context, program))
+        {
+            context->useProgram(program);
+        }
+    }
+}
+
+void GL_APIENTRY ValidateProgram(GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ValidateProgram, context, program);
+        if (context->skipValidation() || ValidateValidateProgram(context, program))
+        {
+            context->validateProgram(program);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib1f(GLuint index, GLfloat x)
+{
+    EVENT("(GLuint index = %u, GLfloat x = %f)", index, x);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttrib1f, context, index, x);
+        if (context->skipValidation() || ValidateVertexAttrib1f(context, index, x))
+        {
+            context->vertexAttrib1f(index, x);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib1fv(GLuint index, const GLfloat *v)
+{
+    EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttrib1fv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttrib1fv(context, index, v))
+        {
+            context->vertexAttrib1fv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
+{
+    EVENT("(GLuint index = %u, GLfloat x = %f, GLfloat y = %f)", index, x, y);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttrib2f, context, index, x, y);
+        if (context->skipValidation() || ValidateVertexAttrib2f(context, index, x, y))
+        {
+            context->vertexAttrib2f(index, x, y);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib2fv(GLuint index, const GLfloat *v)
+{
+    EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttrib2fv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttrib2fv(context, index, v))
+        {
+            context->vertexAttrib2fv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+    EVENT("(GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", index, x, y, z);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttrib3f, context, index, x, y, z);
+        if (context->skipValidation() || ValidateVertexAttrib3f(context, index, x, y, z))
+        {
+            context->vertexAttrib3f(index, x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib3fv(GLuint index, const GLfloat *v)
+{
+    EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttrib3fv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttrib3fv(context, index, v))
+        {
+            context->vertexAttrib3fv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    EVENT("(GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)",
+          index, x, y, z, w);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttrib4f, context, index, x, y, z, w);
+        if (context->skipValidation() || ValidateVertexAttrib4f(context, index, x, y, z, w))
+        {
+            context->vertexAttrib4f(index, x, y, z, w);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib4fv(GLuint index, const GLfloat *v)
+{
+    EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttrib4fv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttrib4fv(context, index, v))
+        {
+            context->vertexAttrib4fv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribPointer(GLuint index,
+                                     GLint size,
+                                     GLenum type,
+                                     GLboolean normalized,
+                                     GLsizei stride,
+                                     const void *pointer)
+{
+    EVENT(
+        "(GLuint index = %u, GLint size = %d, GLenum type = 0x%X, GLboolean normalized = %u, "
+        "GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR ")",
+        index, size, type, normalized, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexAttribPointer, context, index, size, typePacked, normalized, stride,
+                      pointer);
+        if (context->skipValidation() ||
+            ValidateVertexAttribPointer(context, index, size, typePacked, normalized, stride,
+                                        pointer))
+        {
+            context->vertexAttribPointer(index, size, typePacked, normalized, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width,
+          height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Viewport, context, x, y, width, height);
+        if (context->skipValidation() || ValidateViewport(context, x, y, width, height))
+        {
+            context->viewport(x, y, width, height);
+        }
+    }
+}
+}  // namespace gl
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.h
new file mode 100644
index 0000000000..4b2a0f53cb
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.h
@@ -0,0 +1,297 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_2_0_autogen.h:
+//   Defines the GLES 2.0 entry points.
+
+#ifndef LIBGLESV2_ENTRY_POINTS_GLES_2_0_AUTOGEN_H_
+#define LIBGLESV2_ENTRY_POINTS_GLES_2_0_AUTOGEN_H_
+
+#include <GLES2/gl2.h>
+#include <export.h>
+
+namespace gl
+{
+ANGLE_EXPORT void GL_APIENTRY ActiveTexture(GLenum texture);
+ANGLE_EXPORT void GL_APIENTRY AttachShader(GLuint program, GLuint shader);
+ANGLE_EXPORT void GL_APIENTRY BindAttribLocation(GLuint program, GLuint index, const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY BindBuffer(GLenum target, GLuint buffer);
+ANGLE_EXPORT void GL_APIENTRY BindFramebuffer(GLenum target, GLuint framebuffer);
+ANGLE_EXPORT void GL_APIENTRY BindRenderbuffer(GLenum target, GLuint renderbuffer);
+ANGLE_EXPORT void GL_APIENTRY BindTexture(GLenum target, GLuint texture);
+ANGLE_EXPORT void GL_APIENTRY BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ANGLE_EXPORT void GL_APIENTRY BlendEquation(GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
+ANGLE_EXPORT void GL_APIENTRY BlendFunc(GLenum sfactor, GLenum dfactor);
+ANGLE_EXPORT void GL_APIENTRY BlendFuncSeparate(GLenum sfactorRGB,
+                                                GLenum dfactorRGB,
+                                                GLenum sfactorAlpha,
+                                                GLenum dfactorAlpha);
+ANGLE_EXPORT void GL_APIENTRY BufferData(GLenum target,
+                                         GLsizeiptr size,
+                                         const void *data,
+                                         GLenum usage);
+ANGLE_EXPORT void GL_APIENTRY BufferSubData(GLenum target,
+                                            GLintptr offset,
+                                            GLsizeiptr size,
+                                            const void *data);
+ANGLE_EXPORT GLenum GL_APIENTRY CheckFramebufferStatus(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY Clear(GLbitfield mask);
+ANGLE_EXPORT void GL_APIENTRY ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ANGLE_EXPORT void GL_APIENTRY ClearDepthf(GLfloat d);
+ANGLE_EXPORT void GL_APIENTRY ClearStencil(GLint s);
+ANGLE_EXPORT void GL_APIENTRY ColorMask(GLboolean red,
+                                        GLboolean green,
+                                        GLboolean blue,
+                                        GLboolean alpha);
+ANGLE_EXPORT void GL_APIENTRY CompileShader(GLuint shader);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage2D(GLenum target,
+                                                   GLint level,
+                                                   GLenum internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLint border,
+                                                   GLsizei imageSize,
+                                                   const void *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage2D(GLenum target,
+                                                      GLint level,
+                                                      GLint xoffset,
+                                                      GLint yoffset,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLenum format,
+                                                      GLsizei imageSize,
+                                                      const void *data);
+ANGLE_EXPORT void GL_APIENTRY CopyTexImage2D(GLenum target,
+                                             GLint level,
+                                             GLenum internalformat,
+                                             GLint x,
+                                             GLint y,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLint border);
+ANGLE_EXPORT void GL_APIENTRY CopyTexSubImage2D(GLenum target,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint x,
+                                                GLint y,
+                                                GLsizei width,
+                                                GLsizei height);
+ANGLE_EXPORT GLuint GL_APIENTRY CreateProgram();
+ANGLE_EXPORT GLuint GL_APIENTRY CreateShader(GLenum type);
+ANGLE_EXPORT void GL_APIENTRY CullFace(GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY DeleteBuffers(GLsizei n, const GLuint *buffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteFramebuffers(GLsizei n, const GLuint *framebuffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteProgram(GLuint program);
+ANGLE_EXPORT void GL_APIENTRY DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteShader(GLuint shader);
+ANGLE_EXPORT void GL_APIENTRY DeleteTextures(GLsizei n, const GLuint *textures);
+ANGLE_EXPORT void GL_APIENTRY DepthFunc(GLenum func);
+ANGLE_EXPORT void GL_APIENTRY DepthMask(GLboolean flag);
+ANGLE_EXPORT void GL_APIENTRY DepthRangef(GLfloat n, GLfloat f);
+ANGLE_EXPORT void GL_APIENTRY DetachShader(GLuint program, GLuint shader);
+ANGLE_EXPORT void GL_APIENTRY Disable(GLenum cap);
+ANGLE_EXPORT void GL_APIENTRY DisableVertexAttribArray(GLuint index);
+ANGLE_EXPORT void GL_APIENTRY DrawArrays(GLenum mode, GLint first, GLsizei count);
+ANGLE_EXPORT void GL_APIENTRY DrawElements(GLenum mode,
+                                           GLsizei count,
+                                           GLenum type,
+                                           const void *indices);
+ANGLE_EXPORT void GL_APIENTRY Enable(GLenum cap);
+ANGLE_EXPORT void GL_APIENTRY EnableVertexAttribArray(GLuint index);
+ANGLE_EXPORT void GL_APIENTRY Finish();
+ANGLE_EXPORT void GL_APIENTRY Flush();
+ANGLE_EXPORT void GL_APIENTRY FramebufferRenderbuffer(GLenum target,
+                                                      GLenum attachment,
+                                                      GLenum renderbuffertarget,
+                                                      GLuint renderbuffer);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTexture2D(GLenum target,
+                                                   GLenum attachment,
+                                                   GLenum textarget,
+                                                   GLuint texture,
+                                                   GLint level);
+ANGLE_EXPORT void GL_APIENTRY FrontFace(GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY GenBuffers(GLsizei n, GLuint *buffers);
+ANGLE_EXPORT void GL_APIENTRY GenFramebuffers(GLsizei n, GLuint *framebuffers);
+ANGLE_EXPORT void GL_APIENTRY GenRenderbuffers(GLsizei n, GLuint *renderbuffers);
+ANGLE_EXPORT void GL_APIENTRY GenTextures(GLsizei n, GLuint *textures);
+ANGLE_EXPORT void GL_APIENTRY GenerateMipmap(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY GetActiveAttrib(GLuint program,
+                                              GLuint index,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLint *size,
+                                              GLenum *type,
+                                              GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniform(GLuint program,
+                                               GLuint index,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *size,
+                                               GLenum *type,
+                                               GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetAttachedShaders(GLuint program,
+                                                 GLsizei maxCount,
+                                                 GLsizei *count,
+                                                 GLuint *shaders);
+ANGLE_EXPORT GLint GL_APIENTRY GetAttribLocation(GLuint program, const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetBooleanv(GLenum pname, GLboolean *data);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT GLenum GL_APIENTRY GetError();
+ANGLE_EXPORT void GL_APIENTRY GetFloatv(GLenum pname, GLfloat *data);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target,
+                                                                  GLenum attachment,
+                                                                  GLenum pname,
+                                                                  GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetIntegerv(GLenum pname, GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetProgramInfoLog(GLuint program,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLchar *infoLog);
+ANGLE_EXPORT void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetRenderbufferParameteriv(GLenum target,
+                                                         GLenum pname,
+                                                         GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetShaderInfoLog(GLuint shader,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLchar *infoLog);
+ANGLE_EXPORT void GL_APIENTRY GetShaderPrecisionFormat(GLenum shadertype,
+                                                       GLenum precisiontype,
+                                                       GLint *range,
+                                                       GLint *precision);
+ANGLE_EXPORT void GL_APIENTRY GetShaderSource(GLuint shader,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLchar *source);
+ANGLE_EXPORT void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint *params);
+ANGLE_EXPORT const GLubyte *GL_APIENTRY GetString(GLenum name);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetUniformfv(GLuint program, GLint location, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformiv(GLuint program, GLint location, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY Hint(GLenum target, GLenum mode);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsBuffer(GLuint buffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsEnabled(GLenum cap);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsFramebuffer(GLuint framebuffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsProgram(GLuint program);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsRenderbuffer(GLuint renderbuffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsShader(GLuint shader);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsTexture(GLuint texture);
+ANGLE_EXPORT void GL_APIENTRY LineWidth(GLfloat width);
+ANGLE_EXPORT void GL_APIENTRY LinkProgram(GLuint program);
+ANGLE_EXPORT void GL_APIENTRY PixelStorei(GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY PolygonOffset(GLfloat factor, GLfloat units);
+ANGLE_EXPORT void GL_APIENTRY ReadPixels(GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLenum format,
+                                         GLenum type,
+                                         void *pixels);
+ANGLE_EXPORT void GL_APIENTRY ReleaseShaderCompiler();
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorage(GLenum target,
+                                                  GLenum internalformat,
+                                                  GLsizei width,
+                                                  GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY SampleCoverage(GLfloat value, GLboolean invert);
+ANGLE_EXPORT void GL_APIENTRY Scissor(GLint x, GLint y, GLsizei width, GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY ShaderBinary(GLsizei count,
+                                           const GLuint *shaders,
+                                           GLenum binaryformat,
+                                           const void *binary,
+                                           GLsizei length);
+ANGLE_EXPORT void GL_APIENTRY ShaderSource(GLuint shader,
+                                           GLsizei count,
+                                           const GLchar *const *string,
+                                           const GLint *length);
+ANGLE_EXPORT void GL_APIENTRY StencilFunc(GLenum func, GLint ref, GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilMask(GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilMaskSeparate(GLenum face, GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilOp(GLenum fail, GLenum zfail, GLenum zpass);
+ANGLE_EXPORT void GL_APIENTRY StencilOpSeparate(GLenum face,
+                                                GLenum sfail,
+                                                GLenum dpfail,
+                                                GLenum dppass);
+ANGLE_EXPORT void GL_APIENTRY TexImage2D(GLenum target,
+                                         GLint level,
+                                         GLint internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type,
+                                         const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexParameterf(GLenum target, GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY TexParameterfv(GLenum target, GLenum pname, const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameteri(GLenum target, GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY TexParameteriv(GLenum target, GLenum pname, const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage2D(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY Uniform1f(GLint location, GLfloat v0);
+ANGLE_EXPORT void GL_APIENTRY Uniform1fv(GLint location, GLsizei count, const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform1i(GLint location, GLint v0);
+ANGLE_EXPORT void GL_APIENTRY Uniform1iv(GLint location, GLsizei count, const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform2f(GLint location, GLfloat v0, GLfloat v1);
+ANGLE_EXPORT void GL_APIENTRY Uniform2fv(GLint location, GLsizei count, const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform2i(GLint location, GLint v0, GLint v1);
+ANGLE_EXPORT void GL_APIENTRY Uniform2iv(GLint location, GLsizei count, const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ANGLE_EXPORT void GL_APIENTRY Uniform3fv(GLint location, GLsizei count, const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform3i(GLint location, GLint v0, GLint v1, GLint v2);
+ANGLE_EXPORT void GL_APIENTRY Uniform3iv(GLint location, GLsizei count, const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY
+Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ANGLE_EXPORT void GL_APIENTRY Uniform4fv(GLint location, GLsizei count, const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ANGLE_EXPORT void GL_APIENTRY Uniform4iv(GLint location, GLsizei count, const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix2fv(GLint location,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix3fv(GLint location,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix4fv(GLint location,
+                                               GLsizei count,
+                                               GLboolean transpose,
+                                               const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UseProgram(GLuint program);
+ANGLE_EXPORT void GL_APIENTRY ValidateProgram(GLuint program);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib1f(GLuint index, GLfloat x);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib1fv(GLuint index, const GLfloat *v);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib2fv(GLuint index, const GLfloat *v);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib3fv(GLuint index, const GLfloat *v);
+ANGLE_EXPORT void GL_APIENTRY
+VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib4fv(GLuint index, const GLfloat *v);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribPointer(GLuint index,
+                                                  GLint size,
+                                                  GLenum type,
+                                                  GLboolean normalized,
+                                                  GLsizei stride,
+                                                  const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
+}  // namespace gl
+
+#endif  // LIBGLESV2_ENTRY_POINTS_GLES_2_0_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.cpp
new file mode 100644
index 0000000000..b57a8ddd19
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.cpp
@@ -0,0 +1,2005 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_3_0_autogen.cpp:
+//   Defines the GLES 3.0 entry points.
+
+#include "libGLESv2/entry_points_gles_3_0_autogen.h"
+
+#include "libANGLE/Context.h"
+#include "libANGLE/Context.inl.h"
+#include "libANGLE/capture_gles_3_0_autogen.h"
+#include "libANGLE/entry_points_utils.h"
+#include "libANGLE/validationES3.h"
+#include "libGLESv2/global_state.h"
+
+namespace gl
+{
+void GL_APIENTRY BeginQuery(GLenum target, GLuint id)
+{
+    EVENT("(GLenum target = 0x%X, GLuint id = %u)", target, id);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(BeginQuery, context, targetPacked, id);
+        if (context->skipValidation() || ValidateBeginQuery(context, targetPacked, id))
+        {
+            context->beginQuery(targetPacked, id);
+        }
+    }
+}
+
+void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode)
+{
+    EVENT("(GLenum primitiveMode = 0x%X)", primitiveMode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode primitiveModePacked = FromGLenum<PrimitiveMode>(primitiveMode);
+        ANGLE_CAPTURE(BeginTransformFeedback, context, primitiveModePacked);
+        if (context->skipValidation() ||
+            ValidateBeginTransformFeedback(context, primitiveModePacked))
+        {
+            context->beginTransformFeedback(primitiveModePacked);
+        }
+    }
+}
+
+void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLuint buffer = %u)", target, index, buffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(BindBufferBase, context, targetPacked, index, buffer);
+        if (context->skipValidation() ||
+            ValidateBindBufferBase(context, targetPacked, index, buffer))
+        {
+            context->bindBufferBase(targetPacked, index, buffer);
+        }
+    }
+}
+
+void GL_APIENTRY
+BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLuint index = %u, GLuint buffer = %u, GLintptr offset = %llu, "
+        "GLsizeiptr size = %llu)",
+        target, index, buffer, static_cast<unsigned long long>(offset),
+        static_cast<unsigned long long>(size));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(BindBufferRange, context, targetPacked, index, buffer, offset, size);
+        if (context->skipValidation() ||
+            ValidateBindBufferRange(context, targetPacked, index, buffer, offset, size))
+        {
+            context->bindBufferRange(targetPacked, index, buffer, offset, size);
+        }
+    }
+}
+
+void GL_APIENTRY BindSampler(GLuint unit, GLuint sampler)
+{
+    EVENT("(GLuint unit = %u, GLuint sampler = %u)", unit, sampler);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindSampler, context, unit, sampler);
+        if (context->skipValidation() || ValidateBindSampler(context, unit, sampler))
+        {
+            context->bindSampler(unit, sampler);
+        }
+    }
+}
+
+void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id)
+{
+    EVENT("(GLenum target = 0x%X, GLuint id = %u)", target, id);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindTransformFeedback, context, target, id);
+        if (context->skipValidation() || ValidateBindTransformFeedback(context, target, id))
+        {
+            context->bindTransformFeedback(target, id);
+        }
+    }
+}
+
+void GL_APIENTRY BindVertexArray(GLuint array)
+{
+    EVENT("(GLuint array = %u)", array);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindVertexArray, context, array);
+        if (context->skipValidation() || ValidateBindVertexArray(context, array))
+        {
+            context->bindVertexArray(array);
+        }
+    }
+}
+
+void GL_APIENTRY BlitFramebuffer(GLint srcX0,
+                                 GLint srcY0,
+                                 GLint srcX1,
+                                 GLint srcY1,
+                                 GLint dstX0,
+                                 GLint dstY0,
+                                 GLint dstX1,
+                                 GLint dstY1,
+                                 GLbitfield mask,
+                                 GLenum filter)
+{
+    EVENT(
+        "(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, GLint dstX0 = "
+        "%d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask = 0x%X, GLenum "
+        "filter = 0x%X)",
+        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BlitFramebuffer, context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
+                      dstY1, mask, filter);
+        if (context->skipValidation() ||
+            ValidateBlitFramebuffer(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
+                                    mask, filter))
+        {
+            context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
+                                     filter);
+        }
+    }
+}
+
+void GL_APIENTRY ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
+{
+    EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, GLfloat depth = %f, GLint stencil = %d)",
+          buffer, drawbuffer, depth, stencil);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearBufferfi, context, buffer, drawbuffer, depth, stencil);
+        if (context->skipValidation() ||
+            ValidateClearBufferfi(context, buffer, drawbuffer, depth, stencil))
+        {
+            context->clearBufferfi(buffer, drawbuffer, depth, stencil);
+        }
+    }
+}
+
+void GL_APIENTRY ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
+{
+    EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          buffer, drawbuffer, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearBufferfv, context, buffer, drawbuffer, value);
+        if (context->skipValidation() || ValidateClearBufferfv(context, buffer, drawbuffer, value))
+        {
+            context->clearBufferfv(buffer, drawbuffer, value);
+        }
+    }
+}
+
+void GL_APIENTRY ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
+{
+    EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          buffer, drawbuffer, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearBufferiv, context, buffer, drawbuffer, value);
+        if (context->skipValidation() || ValidateClearBufferiv(context, buffer, drawbuffer, value))
+        {
+            context->clearBufferiv(buffer, drawbuffer, value);
+        }
+    }
+}
+
+void GL_APIENTRY ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
+{
+    EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          buffer, drawbuffer, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClearBufferuiv, context, buffer, drawbuffer, value);
+        if (context->skipValidation() || ValidateClearBufferuiv(context, buffer, drawbuffer, value))
+        {
+            context->clearBufferuiv(buffer, drawbuffer, value);
+        }
+    }
+}
+
+GLenum GL_APIENTRY ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR ", GLbitfield flags = 0x%X, GLuint64 timeout = %llu)",
+          (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ClientWaitSync, context, sync, flags, timeout);
+        if (context->skipValidation() || ValidateClientWaitSync(context, sync, flags, timeout))
+        {
+            return context->clientWaitSync(sync, flags, timeout);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::ClientWaitSync, GLenum>();
+}
+
+void GL_APIENTRY CompressedTexImage3D(GLenum target,
+                                      GLint level,
+                                      GLenum internalformat,
+                                      GLsizei width,
+                                      GLsizei height,
+                                      GLsizei depth,
+                                      GLint border,
+                                      GLsizei imageSize,
+                                      const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, "
+        "const void *data = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, imageSize, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage3D, context, targetPacked, level, internalformat, width,
+                      height, depth, border, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexImage3D(context, targetPacked, level, internalformat, width,
+                                         height, depth, border, imageSize, data))
+        {
+            context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
+                                          border, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage3D(GLenum target,
+                                         GLint level,
+                                         GLint xoffset,
+                                         GLint yoffset,
+                                         GLint zoffset,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLenum format,
+                                         GLsizei imageSize,
+                                         const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize,
+        (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage3D, context, targetPacked, level, xoffset, yoffset,
+                      zoffset, width, height, depth, format, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexSubImage3D(context, targetPacked, level, xoffset, yoffset, zoffset,
+                                            width, height, depth, format, imageSize, data))
+        {
+            context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
+                                             height, depth, format, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CopyBufferSubData(GLenum readTarget,
+                                   GLenum writeTarget,
+                                   GLintptr readOffset,
+                                   GLintptr writeOffset,
+                                   GLsizeiptr size)
+{
+    EVENT(
+        "(GLenum readTarget = 0x%X, GLenum writeTarget = 0x%X, GLintptr readOffset = %llu, "
+        "GLintptr writeOffset = %llu, GLsizeiptr size = %llu)",
+        readTarget, writeTarget, static_cast<unsigned long long>(readOffset),
+        static_cast<unsigned long long>(writeOffset), static_cast<unsigned long long>(size));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding readTargetPacked  = FromGLenum<BufferBinding>(readTarget);
+        BufferBinding writeTargetPacked = FromGLenum<BufferBinding>(writeTarget);
+        ANGLE_CAPTURE(CopyBufferSubData, context, readTargetPacked, writeTargetPacked, readOffset,
+                      writeOffset, size);
+        if (context->skipValidation() ||
+            ValidateCopyBufferSubData(context, readTargetPacked, writeTargetPacked, readOffset,
+                                      writeOffset, size))
+        {
+            context->copyBufferSubData(readTargetPacked, writeTargetPacked, readOffset, writeOffset,
+                                       size);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexSubImage3D(GLenum target,
+                                   GLint level,
+                                   GLint xoffset,
+                                   GLint yoffset,
+                                   GLint zoffset,
+                                   GLint x,
+                                   GLint y,
+                                   GLsizei width,
+                                   GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+        target, level, xoffset, yoffset, zoffset, x, y, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CopyTexSubImage3D, context, targetPacked, level, xoffset, yoffset, zoffset, x,
+                      y, width, height);
+        if (context->skipValidation() ||
+            ValidateCopyTexSubImage3D(context, targetPacked, level, xoffset, yoffset, zoffset, x, y,
+                                      width, height))
+        {
+            context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
+                                       height);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteQueries(GLsizei n, const GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteQueries, context, n, ids);
+        if (context->skipValidation() || ValidateDeleteQueries(context, n, ids))
+        {
+            context->deleteQueries(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteSamplers(GLsizei count, const GLuint *samplers)
+{
+    EVENT("(GLsizei count = %d, const GLuint *samplers = 0x%016" PRIxPTR ")", count,
+          (uintptr_t)samplers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteSamplers, context, count, samplers);
+        if (context->skipValidation() || ValidateDeleteSamplers(context, count, samplers))
+        {
+            context->deleteSamplers(count, samplers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteSync(GLsync sync)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR ")", (uintptr_t)sync);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteSync, context, sync);
+        if (context->skipValidation() || ValidateDeleteSync(context, sync))
+        {
+            context->deleteSync(sync);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteTransformFeedbacks, context, n, ids);
+        if (context->skipValidation() || ValidateDeleteTransformFeedbacks(context, n, ids))
+        {
+            context->deleteTransformFeedbacks(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteVertexArrays(GLsizei n, const GLuint *arrays)
+{
+    EVENT("(GLsizei n = %d, const GLuint *arrays = 0x%016" PRIxPTR ")", n, (uintptr_t)arrays);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteVertexArrays, context, n, arrays);
+        if (context->skipValidation() || ValidateDeleteVertexArrays(context, n, arrays))
+        {
+            context->deleteVertexArrays(n, arrays);
+        }
+    }
+}
+
+void GL_APIENTRY DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
+{
+    EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei instancecount = %d)",
+          mode, first, count, instancecount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArraysInstanced, context, modePacked, first, count, instancecount);
+        if (context->skipValidation() ||
+            ValidateDrawArraysInstanced(context, modePacked, first, count, instancecount))
+        {
+            context->drawArraysInstanced(modePacked, first, count, instancecount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawBuffers(GLsizei n, const GLenum *bufs)
+{
+    EVENT("(GLsizei n = %d, const GLenum *bufs = 0x%016" PRIxPTR ")", n, (uintptr_t)bufs);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawBuffers, context, n, bufs);
+        if (context->skipValidation() || ValidateDrawBuffers(context, n, bufs))
+        {
+            context->drawBuffers(n, bufs);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsInstanced(GLenum mode,
+                                       GLsizei count,
+                                       GLenum type,
+                                       const void *indices,
+                                       GLsizei instancecount)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = "
+        "0x%016" PRIxPTR ", GLsizei instancecount = %d)",
+        mode, count, type, (uintptr_t)indices, instancecount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElementsInstanced, context, modePacked, count, typePacked, indices,
+                      instancecount);
+        if (context->skipValidation() ||
+            ValidateDrawElementsInstanced(context, modePacked, count, typePacked, indices,
+                                          instancecount))
+        {
+            context->drawElementsInstanced(modePacked, count, typePacked, indices, instancecount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawRangeElements(GLenum mode,
+                                   GLuint start,
+                                   GLuint end,
+                                   GLsizei count,
+                                   GLenum type,
+                                   const void *indices)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLuint start = %u, GLuint end = %u, GLsizei count = %d, GLenum type "
+        "= 0x%X, const void *indices = 0x%016" PRIxPTR ")",
+        mode, start, end, count, type, (uintptr_t)indices);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawRangeElements, context, modePacked, start, end, count, typePacked,
+                      indices);
+        if (context->skipValidation() ||
+            ValidateDrawRangeElements(context, modePacked, start, end, count, typePacked, indices))
+        {
+            context->drawRangeElements(modePacked, start, end, count, typePacked, indices);
+        }
+    }
+}
+
+void GL_APIENTRY EndQuery(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(EndQuery, context, targetPacked);
+        if (context->skipValidation() || ValidateEndQuery(context, targetPacked))
+        {
+            context->endQuery(targetPacked);
+        }
+    }
+}
+
+void GL_APIENTRY EndTransformFeedback()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(EndTransformFeedback, context);
+        if (context->skipValidation() || ValidateEndTransformFeedback(context))
+        {
+            context->endTransformFeedback();
+        }
+    }
+}
+
+GLsync GL_APIENTRY FenceSync(GLenum condition, GLbitfield flags)
+{
+    EVENT("(GLenum condition = 0x%X, GLbitfield flags = 0x%X)", condition, flags);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FenceSync, context, condition, flags);
+        if (context->skipValidation() || ValidateFenceSync(context, condition, flags))
+        {
+            return context->fenceSync(condition, flags);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::FenceSync, GLsync>();
+}
+
+void GL_APIENTRY FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
+{
+    EVENT("(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr length = %llu)", target,
+          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(FlushMappedBufferRange, context, targetPacked, offset, length);
+        if (context->skipValidation() ||
+            ValidateFlushMappedBufferRange(context, targetPacked, offset, length))
+        {
+            context->flushMappedBufferRange(targetPacked, offset, length);
+        }
+    }
+}
+
+void GL_APIENTRY
+FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d, "
+        "GLint layer = %d)",
+        target, attachment, texture, level, layer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FramebufferTextureLayer, context, target, attachment, texture, level, layer);
+        if (context->skipValidation() ||
+            ValidateFramebufferTextureLayer(context, target, attachment, texture, level, layer))
+        {
+            context->framebufferTextureLayer(target, attachment, texture, level, layer);
+        }
+    }
+}
+
+void GL_APIENTRY GenQueries(GLsizei n, GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenQueries, context, n, ids);
+        if (context->skipValidation() || ValidateGenQueries(context, n, ids))
+        {
+            context->genQueries(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY GenSamplers(GLsizei count, GLuint *samplers)
+{
+    EVENT("(GLsizei count = %d, GLuint *samplers = 0x%016" PRIxPTR ")", count, (uintptr_t)samplers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenSamplers, context, count, samplers);
+        if (context->skipValidation() || ValidateGenSamplers(context, count, samplers))
+        {
+            context->genSamplers(count, samplers);
+        }
+    }
+}
+
+void GL_APIENTRY GenTransformFeedbacks(GLsizei n, GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenTransformFeedbacks, context, n, ids);
+        if (context->skipValidation() || ValidateGenTransformFeedbacks(context, n, ids))
+        {
+            context->genTransformFeedbacks(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY GenVertexArrays(GLsizei n, GLuint *arrays)
+{
+    EVENT("(GLsizei n = %d, GLuint *arrays = 0x%016" PRIxPTR ")", n, (uintptr_t)arrays);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenVertexArrays, context, n, arrays);
+        if (context->skipValidation() || ValidateGenVertexArrays(context, n, arrays))
+        {
+            context->genVertexArrays(n, arrays);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformBlockName(GLuint program,
+                                           GLuint uniformBlockIndex,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLchar *uniformBlockName)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint uniformBlockIndex = %u, GLsizei bufSize = %d, GLsizei "
+        "*length = 0x%016" PRIxPTR ", GLchar *uniformBlockName = 0x%016" PRIxPTR ")",
+        program, uniformBlockIndex, bufSize, (uintptr_t)length, (uintptr_t)uniformBlockName);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetActiveUniformBlockName, context, program, uniformBlockIndex, bufSize,
+                      length, uniformBlockName);
+        if (context->skipValidation() ||
+            ValidateGetActiveUniformBlockName(context, program, uniformBlockIndex, bufSize, length,
+                                              uniformBlockName))
+        {
+            context->getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length,
+                                               uniformBlockName);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformBlockiv(GLuint program,
+                                         GLuint uniformBlockIndex,
+                                         GLenum pname,
+                                         GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = 0x%X, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        program, uniformBlockIndex, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetActiveUniformBlockiv, context, program, uniformBlockIndex, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetActiveUniformBlockiv(context, program, uniformBlockIndex, pname, params))
+        {
+            context->getActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformsiv(GLuint program,
+                                     GLsizei uniformCount,
+                                     const GLuint *uniformIndices,
+                                     GLenum pname,
+                                     GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLsizei uniformCount = %d, const GLuint *uniformIndices = "
+        "0x%016" PRIxPTR ", GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")",
+        program, uniformCount, (uintptr_t)uniformIndices, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetActiveUniformsiv, context, program, uniformCount, uniformIndices, pname,
+                      params);
+        if (context->skipValidation() || ValidateGetActiveUniformsiv(context, program, uniformCount,
+                                                                     uniformIndices, pname, params))
+        {
+            context->getActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint64 *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferParameteri64v, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetBufferParameteri64v(context, targetPacked, pname, params))
+        {
+            context->getBufferParameteri64v(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferPointerv(GLenum target, GLenum pname, void **params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, void **params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferPointerv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetBufferPointerv(context, targetPacked, pname, params))
+        {
+            context->getBufferPointerv(targetPacked, pname, params);
+        }
+    }
+}
+
+GLint GL_APIENTRY GetFragDataLocation(GLuint program, const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFragDataLocation, context, program, name);
+        if (context->skipValidation() || ValidateGetFragDataLocation(context, program, name))
+        {
+            return context->getFragDataLocation(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetFragDataLocation, GLint>();
+}
+
+void GL_APIENTRY GetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLint64 *data = 0x%016" PRIxPTR ")", target,
+          index, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetInteger64i_v, context, target, index, data);
+        if (context->skipValidation() || ValidateGetInteger64i_v(context, target, index, data))
+        {
+            context->getInteger64i_v(target, index, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetInteger64v(GLenum pname, GLint64 *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLint64 *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetInteger64v, context, pname, data);
+        if (context->skipValidation() || ValidateGetInteger64v(context, pname, data))
+        {
+            context->getInteger64v(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLint *data = 0x%016" PRIxPTR ")", target,
+          index, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetIntegeri_v, context, target, index, data);
+        if (context->skipValidation() || ValidateGetIntegeri_v(context, target, index, data))
+        {
+            context->getIntegeri_v(target, index, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetInternalformativ(GLenum target,
+                                     GLenum internalformat,
+                                     GLenum pname,
+                                     GLsizei bufSize,
+                                     GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLenum pname = 0x%X, GLsizei bufSize "
+        "= %d, GLint *params = 0x%016" PRIxPTR ")",
+        target, internalformat, pname, bufSize, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetInternalformativ, context, target, internalformat, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateGetInternalformativ(context, target, internalformat, pname, bufSize, params))
+        {
+            context->getInternalformativ(target, internalformat, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramBinary(GLuint program,
+                                  GLsizei bufSize,
+                                  GLsizei *length,
+                                  GLenum *binaryFormat,
+                                  void *binary)
+{
+    EVENT("(GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR ")",
+          program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat, (uintptr_t)binary);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramBinary, context, program, bufSize, length, binaryFormat, binary);
+        if (context->skipValidation() ||
+            ValidateGetProgramBinary(context, program, bufSize, length, binaryFormat, binary))
+        {
+            context->getProgramBinary(program, bufSize, length, binaryFormat, binary);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjectuiv, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjectuiv(context, id, pname, params))
+        {
+            context->getQueryObjectuiv(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryiv(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(GetQueryiv, context, targetPacked, pname, params);
+        if (context->skipValidation() || ValidateGetQueryiv(context, targetPacked, pname, params))
+        {
+            context->getQueryiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSamplerParameterfv, context, sampler, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSamplerParameterfv(context, sampler, pname, params))
+        {
+            context->getSamplerParameterfv(sampler, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", sampler,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSamplerParameteriv, context, sampler, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSamplerParameteriv(context, sampler, pname, params))
+        {
+            context->getSamplerParameteriv(sampler, pname, params);
+        }
+    }
+}
+
+const GLubyte *GL_APIENTRY GetStringi(GLenum name, GLuint index)
+{
+    EVENT("(GLenum name = 0x%X, GLuint index = %u)", name, index);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetStringi, context, name, index);
+        if (context->skipValidation() || ValidateGetStringi(context, name, index))
+        {
+            return context->getStringi(name, index);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetStringi, const GLubyte *>();
+}
+
+void GL_APIENTRY
+GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR
+          ", GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLint *values = 0x%016" PRIxPTR ")",
+          (uintptr_t)sync, pname, bufSize, (uintptr_t)length, (uintptr_t)values);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSynciv, context, sync, pname, bufSize, length, values);
+        if (context->skipValidation() ||
+            ValidateGetSynciv(context, sync, pname, bufSize, length, values))
+        {
+            context->getSynciv(sync, pname, bufSize, length, values);
+        }
+    }
+}
+
+void GL_APIENTRY GetTransformFeedbackVarying(GLuint program,
+                                             GLuint index,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLsizei *size,
+                                             GLenum *type,
+                                             GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei *length = "
+        "0x%016" PRIxPTR ", GLsizei *size = 0x%016" PRIxPTR ", GLenum *type = 0x%016" PRIxPTR
+        ", GLchar *name = 0x%016" PRIxPTR ")",
+        program, index, bufSize, (uintptr_t)length, (uintptr_t)size, (uintptr_t)type,
+        (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetTransformFeedbackVarying, context, program, index, bufSize, length, size,
+                      type, name);
+        if (context->skipValidation() ||
+            ValidateGetTransformFeedbackVarying(context, program, index, bufSize, length, size,
+                                                type, name))
+        {
+            context->getTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+        }
+    }
+}
+
+GLuint GL_APIENTRY GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
+{
+    EVENT("(GLuint program = %u, const GLchar *uniformBlockName = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)uniformBlockName);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformBlockIndex, context, program, uniformBlockName);
+        if (context->skipValidation() ||
+            ValidateGetUniformBlockIndex(context, program, uniformBlockName))
+        {
+            return context->getUniformBlockIndex(program, uniformBlockName);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetUniformBlockIndex, GLuint>();
+}
+
+void GL_APIENTRY GetUniformIndices(GLuint program,
+                                   GLsizei uniformCount,
+                                   const GLchar *const *uniformNames,
+                                   GLuint *uniformIndices)
+{
+    EVENT(
+        "(GLuint program = %u, GLsizei uniformCount = %d, const GLchar *const*uniformNames = "
+        "0x%016" PRIxPTR ", GLuint *uniformIndices = 0x%016" PRIxPTR ")",
+        program, uniformCount, (uintptr_t)uniformNames, (uintptr_t)uniformIndices);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformIndices, context, program, uniformCount, uniformNames,
+                      uniformIndices);
+        if (context->skipValidation() ||
+            ValidateGetUniformIndices(context, program, uniformCount, uniformNames, uniformIndices))
+        {
+            context->getUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformuiv(GLuint program, GLint location, GLuint *params)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLuint *params = 0x%016" PRIxPTR ")", program,
+          location, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformuiv, context, program, location, params);
+        if (context->skipValidation() || ValidateGetUniformuiv(context, program, location, params))
+        {
+            context->getUniformuiv(program, location, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribIiv, context, index, pname, params);
+        if (context->skipValidation() || ValidateGetVertexAttribIiv(context, index, pname, params))
+        {
+            context->getVertexAttribIiv(index, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribIuiv, context, index, pname, params);
+        if (context->skipValidation() || ValidateGetVertexAttribIuiv(context, index, pname, params))
+        {
+            context->getVertexAttribIuiv(index, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY InvalidateFramebuffer(GLenum target,
+                                       GLsizei numAttachments,
+                                       const GLenum *attachments)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum *attachments = "
+        "0x%016" PRIxPTR ")",
+        target, numAttachments, (uintptr_t)attachments);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(InvalidateFramebuffer, context, target, numAttachments, attachments);
+        if (context->skipValidation() ||
+            ValidateInvalidateFramebuffer(context, target, numAttachments, attachments))
+        {
+            context->invalidateFramebuffer(target, numAttachments, attachments);
+        }
+    }
+}
+
+void GL_APIENTRY InvalidateSubFramebuffer(GLenum target,
+                                          GLsizei numAttachments,
+                                          const GLenum *attachments,
+                                          GLint x,
+                                          GLint y,
+                                          GLsizei width,
+                                          GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum *attachments = "
+        "0x%016" PRIxPTR ", GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+        target, numAttachments, (uintptr_t)attachments, x, y, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(InvalidateSubFramebuffer, context, target, numAttachments, attachments, x, y,
+                      width, height);
+        if (context->skipValidation() ||
+            ValidateInvalidateSubFramebuffer(context, target, numAttachments, attachments, x, y,
+                                             width, height))
+        {
+            context->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
+                                              height);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsQuery(GLuint id)
+{
+    EVENT("(GLuint id = %u)", id);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsQuery, context, id);
+        if (context->skipValidation() || ValidateIsQuery(context, id))
+        {
+            return context->isQuery(id);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsQuery, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsSampler(GLuint sampler)
+{
+    EVENT("(GLuint sampler = %u)", sampler);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsSampler, context, sampler);
+        if (context->skipValidation() || ValidateIsSampler(context, sampler))
+        {
+            return context->isSampler(sampler);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsSampler, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsSync(GLsync sync)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR ")", (uintptr_t)sync);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsSync, context, sync);
+        if (context->skipValidation() || ValidateIsSync(context, sync))
+        {
+            return context->isSync(sync);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsSync, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsTransformFeedback(GLuint id)
+{
+    EVENT("(GLuint id = %u)", id);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsTransformFeedback, context, id);
+        if (context->skipValidation() || ValidateIsTransformFeedback(context, id))
+        {
+            return context->isTransformFeedback(id);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsVertexArray(GLuint array)
+{
+    EVENT("(GLuint array = %u)", array);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsVertexArray, context, array);
+        if (context->skipValidation() || ValidateIsVertexArray(context, array))
+        {
+            return context->isVertexArray(array);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsVertexArray, GLboolean>();
+}
+
+void *GL_APIENTRY MapBufferRange(GLenum target,
+                                 GLintptr offset,
+                                 GLsizeiptr length,
+                                 GLbitfield access)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr length = %llu, GLbitfield "
+        "access = 0x%X)",
+        target, static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
+        access);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(MapBufferRange, context, targetPacked, offset, length, access);
+        if (context->skipValidation() ||
+            ValidateMapBufferRange(context, targetPacked, offset, length, access))
+        {
+            return context->mapBufferRange(targetPacked, offset, length, access);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::MapBufferRange, void *>();
+}
+
+void GL_APIENTRY PauseTransformFeedback()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PauseTransformFeedback, context);
+        if (context->skipValidation() || ValidatePauseTransformFeedback(context))
+        {
+            context->pauseTransformFeedback();
+        }
+    }
+}
+
+void GL_APIENTRY ProgramBinary(GLuint program,
+                               GLenum binaryFormat,
+                               const void *binary,
+                               GLsizei length)
+{
+    EVENT("(GLuint program = %u, GLenum binaryFormat = 0x%X, const void *binary = 0x%016" PRIxPTR
+          ", GLsizei length = %d)",
+          program, binaryFormat, (uintptr_t)binary, length);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramBinary, context, program, binaryFormat, binary, length);
+        if (context->skipValidation() ||
+            ValidateProgramBinary(context, program, binaryFormat, binary, length))
+        {
+            context->programBinary(program, binaryFormat, binary, length);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramParameteri(GLuint program, GLenum pname, GLint value)
+{
+    EVENT("(GLuint program = %u, GLenum pname = 0x%X, GLint value = %d)", program, pname, value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramParameteri, context, program, pname, value);
+        if (context->skipValidation() || ValidateProgramParameteri(context, program, pname, value))
+        {
+            context->programParameteri(program, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY ReadBuffer(GLenum src)
+{
+    EVENT("(GLenum src = 0x%X)", src);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ReadBuffer, context, src);
+        if (context->skipValidation() || ValidateReadBuffer(context, src))
+        {
+            context->readBuffer(src);
+        }
+    }
+}
+
+void GL_APIENTRY RenderbufferStorageMultisample(GLenum target,
+                                                GLsizei samples,
+                                                GLenum internalformat,
+                                                GLsizei width,
+                                                GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d)",
+        target, samples, internalformat, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(RenderbufferStorageMultisample, context, target, samples, internalformat,
+                      width, height);
+        if (context->skipValidation() ||
+            ValidateRenderbufferStorageMultisample(context, target, samples, internalformat, width,
+                                                   height))
+        {
+            context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY ResumeTransformFeedback()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ResumeTransformFeedback, context);
+        if (context->skipValidation() || ValidateResumeTransformFeedback(context))
+        {
+            context->resumeTransformFeedback();
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLfloat param = %f)", sampler, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameterf, context, sampler, pname, param);
+        if (context->skipValidation() || ValidateSamplerParameterf(context, sampler, pname, param))
+        {
+            context->samplerParameterf(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLfloat *param = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameterfv, context, sampler, pname, param);
+        if (context->skipValidation() || ValidateSamplerParameterfv(context, sampler, pname, param))
+        {
+            context->samplerParameterfv(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint param = %d)", sampler, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameteri, context, sampler, pname, param);
+        if (context->skipValidation() || ValidateSamplerParameteri(context, sampler, pname, param))
+        {
+            context->samplerParameteri(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLint *param = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameteriv, context, sampler, pname, param);
+        if (context->skipValidation() || ValidateSamplerParameteriv(context, sampler, pname, param))
+        {
+            context->samplerParameteriv(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage3D(GLenum target,
+                            GLint level,
+                            GLint internalformat,
+                            GLsizei width,
+                            GLsizei height,
+                            GLsizei depth,
+                            GLint border,
+                            GLenum format,
+                            GLenum type,
+                            const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, GLenum "
+        "type = 0x%X, const void *pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, format, type,
+        (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage3D, context, targetPacked, level, internalformat, width, height,
+                      depth, border, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage3D(context, targetPacked, level, internalformat, width, height, depth,
+                               border, format, type, pixels))
+        {
+            context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
+                                format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY
+TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d)",
+        target, levels, internalformat, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage2D, context, targetPacked, levels, internalformat, width, height);
+        if (context->skipValidation() ||
+            ValidateTexStorage2D(context, targetPacked, levels, internalformat, width, height))
+        {
+            context->texStorage2D(targetPacked, levels, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage3D(GLenum target,
+                              GLsizei levels,
+                              GLenum internalformat,
+                              GLsizei width,
+                              GLsizei height,
+                              GLsizei depth)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d)",
+        target, levels, internalformat, width, height, depth);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage3D, context, targetPacked, levels, internalformat, width, height,
+                      depth);
+        if (context->skipValidation() || ValidateTexStorage3D(context, targetPacked, levels,
+                                                              internalformat, width, height, depth))
+        {
+            context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage3D(GLenum target,
+                               GLint level,
+                               GLint xoffset,
+                               GLint yoffset,
+                               GLint zoffset,
+                               GLsizei width,
+                               GLsizei height,
+                               GLsizei depth,
+                               GLenum format,
+                               GLenum type,
+                               const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLenum type = 0x%X, const void *pixels = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, type,
+        (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage3D, context, targetPacked, level, xoffset, yoffset, zoffset, width,
+                      height, depth, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage3D(context, targetPacked, level, xoffset, yoffset, zoffset, width,
+                                  height, depth, format, type, pixels))
+        {
+            context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
+                                   depth, format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TransformFeedbackVaryings(GLuint program,
+                                           GLsizei count,
+                                           const GLchar *const *varyings,
+                                           GLenum bufferMode)
+{
+    EVENT("(GLuint program = %u, GLsizei count = %d, const GLchar *const*varyings = 0x%016" PRIxPTR
+          ", GLenum bufferMode = 0x%X)",
+          program, count, (uintptr_t)varyings, bufferMode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TransformFeedbackVaryings, context, program, count, varyings, bufferMode);
+        if (context->skipValidation() ||
+            ValidateTransformFeedbackVaryings(context, program, count, varyings, bufferMode))
+        {
+            context->transformFeedbackVaryings(program, count, varyings, bufferMode);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1ui(GLint location, GLuint v0)
+{
+    EVENT("(GLint location = %d, GLuint v0 = %u)", location, v0);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform1ui, context, location, v0);
+        if (context->skipValidation() || ValidateUniform1ui(context, location, v0))
+        {
+            context->uniform1ui(location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform1uiv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform1uiv(context, location, count, value))
+        {
+            context->uniform1uiv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2ui(GLint location, GLuint v0, GLuint v1)
+{
+    EVENT("(GLint location = %d, GLuint v0 = %u, GLuint v1 = %u)", location, v0, v1);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform2ui, context, location, v0, v1);
+        if (context->skipValidation() || ValidateUniform2ui(context, location, v0, v1))
+        {
+            context->uniform2ui(location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform2uiv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform2uiv(context, location, count, value))
+        {
+            context->uniform2uiv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
+{
+    EVENT("(GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = %u)", location, v0, v1,
+          v2);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform3ui, context, location, v0, v1, v2);
+        if (context->skipValidation() || ValidateUniform3ui(context, location, v0, v1, v2))
+        {
+            context->uniform3ui(location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform3uiv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform3uiv(context, location, count, value))
+        {
+            context->uniform3uiv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+{
+    EVENT("(GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = %u, GLuint v3 = %u)",
+          location, v0, v1, v2, v3);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform4ui, context, location, v0, v1, v2, v3);
+        if (context->skipValidation() || ValidateUniform4ui(context, location, v0, v1, v2, v3))
+        {
+            context->uniform4ui(location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(Uniform4uiv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform4uiv(context, location, count, value))
+        {
+            context->uniform4uiv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformBlockBinding(GLuint program,
+                                     GLuint uniformBlockIndex,
+                                     GLuint uniformBlockBinding)
+{
+    EVENT("(GLuint program = %u, GLuint uniformBlockIndex = %u, GLuint uniformBlockBinding = %u)",
+          program, uniformBlockIndex, uniformBlockBinding);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformBlockBinding, context, program, uniformBlockIndex,
+                      uniformBlockBinding);
+        if (context->skipValidation() ||
+            ValidateUniformBlockBinding(context, program, uniformBlockIndex, uniformBlockBinding))
+        {
+            context->uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix2x3fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix2x3fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix2x3fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix2x3fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix2x4fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix2x4fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix2x4fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix2x4fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix3x2fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix3x2fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix3x2fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix3x2fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix3x4fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix3x4fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix3x4fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix3x4fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix4x2fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix4x2fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix4x2fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix4x2fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix4x3fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UniformMatrix4x3fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix4x3fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix4x3fv(location, count, transpose, value);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY UnmapBuffer(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(UnmapBuffer, context, targetPacked);
+        if (context->skipValidation() || ValidateUnmapBuffer(context, targetPacked))
+        {
+            return context->unmapBuffer(targetPacked);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::UnmapBuffer, GLboolean>();
+}
+
+void GL_APIENTRY VertexAttribDivisor(GLuint index, GLuint divisor)
+{
+    EVENT("(GLuint index = %u, GLuint divisor = %u)", index, divisor);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttribDivisor, context, index, divisor);
+        if (context->skipValidation() || ValidateVertexAttribDivisor(context, index, divisor))
+        {
+            context->vertexAttribDivisor(index, divisor);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
+{
+    EVENT("(GLuint index = %u, GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d)", index, x,
+          y, z, w);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttribI4i, context, index, x, y, z, w);
+        if (context->skipValidation() || ValidateVertexAttribI4i(context, index, x, y, z, w))
+        {
+            context->vertexAttribI4i(index, x, y, z, w);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribI4iv(GLuint index, const GLint *v)
+{
+    EVENT("(GLuint index = %u, const GLint *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttribI4iv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttribI4iv(context, index, v))
+        {
+            context->vertexAttribI4iv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+{
+    EVENT("(GLuint index = %u, GLuint x = %u, GLuint y = %u, GLuint z = %u, GLuint w = %u)", index,
+          x, y, z, w);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttribI4ui, context, index, x, y, z, w);
+        if (context->skipValidation() || ValidateVertexAttribI4ui(context, index, x, y, z, w))
+        {
+            context->vertexAttribI4ui(index, x, y, z, w);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribI4uiv(GLuint index, const GLuint *v)
+{
+    EVENT("(GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttribI4uiv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttribI4uiv(context, index, v))
+        {
+            context->vertexAttribI4uiv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY
+VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    EVENT(
+        "(GLuint index = %u, GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void "
+        "*pointer = 0x%016" PRIxPTR ")",
+        index, size, type, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexAttribIPointer, context, index, size, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateVertexAttribIPointer(context, index, size, typePacked, stride, pointer))
+        {
+            context->vertexAttribIPointer(index, size, typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR ", GLbitfield flags = 0x%X, GLuint64 timeout = %llu)",
+          (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(WaitSync, context, sync, flags, timeout);
+        if (context->skipValidation() || ValidateWaitSync(context, sync, flags, timeout))
+        {
+            context->waitSync(sync, flags, timeout);
+        }
+    }
+}
+}  // namespace gl
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.h
new file mode 100644
index 0000000000..6c12fa80ba
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.h
@@ -0,0 +1,284 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_3_0_autogen.h:
+//   Defines the GLES 3.0 entry points.
+
+#ifndef LIBGLESV2_ENTRY_POINTS_GLES_3_0_AUTOGEN_H_
+#define LIBGLESV2_ENTRY_POINTS_GLES_3_0_AUTOGEN_H_
+
+#include <GLES3/gl3.h>
+#include <export.h>
+
+namespace gl
+{
+ANGLE_EXPORT void GL_APIENTRY BeginQuery(GLenum target, GLuint id);
+ANGLE_EXPORT void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode);
+ANGLE_EXPORT void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer);
+ANGLE_EXPORT void GL_APIENTRY
+BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+ANGLE_EXPORT void GL_APIENTRY BindSampler(GLuint unit, GLuint sampler);
+ANGLE_EXPORT void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id);
+ANGLE_EXPORT void GL_APIENTRY BindVertexArray(GLuint array);
+ANGLE_EXPORT void GL_APIENTRY BlitFramebuffer(GLint srcX0,
+                                              GLint srcY0,
+                                              GLint srcX1,
+                                              GLint srcY1,
+                                              GLint dstX0,
+                                              GLint dstY0,
+                                              GLint dstX1,
+                                              GLint dstY1,
+                                              GLbitfield mask,
+                                              GLenum filter);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferfi(GLenum buffer,
+                                            GLint drawbuffer,
+                                            GLfloat depth,
+                                            GLint stencil);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
+ANGLE_EXPORT GLenum GL_APIENTRY ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage3D(GLenum target,
+                                                   GLint level,
+                                                   GLenum internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLsizei depth,
+                                                   GLint border,
+                                                   GLsizei imageSize,
+                                                   const void *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage3D(GLenum target,
+                                                      GLint level,
+                                                      GLint xoffset,
+                                                      GLint yoffset,
+                                                      GLint zoffset,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLsizei depth,
+                                                      GLenum format,
+                                                      GLsizei imageSize,
+                                                      const void *data);
+ANGLE_EXPORT void GL_APIENTRY CopyBufferSubData(GLenum readTarget,
+                                                GLenum writeTarget,
+                                                GLintptr readOffset,
+                                                GLintptr writeOffset,
+                                                GLsizeiptr size);
+ANGLE_EXPORT void GL_APIENTRY CopyTexSubImage3D(GLenum target,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint zoffset,
+                                                GLint x,
+                                                GLint y,
+                                                GLsizei width,
+                                                GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY DeleteQueries(GLsizei n, const GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY DeleteSamplers(GLsizei count, const GLuint *samplers);
+ANGLE_EXPORT void GL_APIENTRY DeleteSync(GLsync sync);
+ANGLE_EXPORT void GL_APIENTRY DeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY DeleteVertexArrays(GLsizei n, const GLuint *arrays);
+ANGLE_EXPORT void GL_APIENTRY DrawArraysInstanced(GLenum mode,
+                                                  GLint first,
+                                                  GLsizei count,
+                                                  GLsizei instancecount);
+ANGLE_EXPORT void GL_APIENTRY DrawBuffers(GLsizei n, const GLenum *bufs);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsInstanced(GLenum mode,
+                                                    GLsizei count,
+                                                    GLenum type,
+                                                    const void *indices,
+                                                    GLsizei instancecount);
+ANGLE_EXPORT void GL_APIENTRY DrawRangeElements(GLenum mode,
+                                                GLuint start,
+                                                GLuint end,
+                                                GLsizei count,
+                                                GLenum type,
+                                                const void *indices);
+ANGLE_EXPORT void GL_APIENTRY EndQuery(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY EndTransformFeedback();
+ANGLE_EXPORT GLsync GL_APIENTRY FenceSync(GLenum condition, GLbitfield flags);
+ANGLE_EXPORT void GL_APIENTRY FlushMappedBufferRange(GLenum target,
+                                                     GLintptr offset,
+                                                     GLsizeiptr length);
+ANGLE_EXPORT void GL_APIENTRY
+FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+ANGLE_EXPORT void GL_APIENTRY GenQueries(GLsizei n, GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY GenSamplers(GLsizei count, GLuint *samplers);
+ANGLE_EXPORT void GL_APIENTRY GenTransformFeedbacks(GLsizei n, GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY GenVertexArrays(GLsizei n, GLuint *arrays);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockName(GLuint program,
+                                                        GLuint uniformBlockIndex,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLchar *uniformBlockName);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockiv(GLuint program,
+                                                      GLuint uniformBlockIndex,
+                                                      GLenum pname,
+                                                      GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformsiv(GLuint program,
+                                                  GLsizei uniformCount,
+                                                  const GLuint *uniformIndices,
+                                                  GLenum pname,
+                                                  GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferPointerv(GLenum target, GLenum pname, void **params);
+ANGLE_EXPORT GLint GL_APIENTRY GetFragDataLocation(GLuint program, const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64v(GLenum pname, GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetInternalformativ(GLenum target,
+                                                  GLenum internalformat,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetProgramBinary(GLuint program,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLenum *binaryFormat,
+                                               void *binary);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryiv(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
+ANGLE_EXPORT const GLubyte *GL_APIENTRY GetStringi(GLenum name, GLuint index);
+ANGLE_EXPORT void GL_APIENTRY
+GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+ANGLE_EXPORT void GL_APIENTRY GetTransformFeedbackVarying(GLuint program,
+                                                          GLuint index,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLsizei *size,
+                                                          GLenum *type,
+                                                          GLchar *name);
+ANGLE_EXPORT GLuint GL_APIENTRY GetUniformBlockIndex(GLuint program,
+                                                     const GLchar *uniformBlockName);
+ANGLE_EXPORT void GL_APIENTRY GetUniformIndices(GLuint program,
+                                                GLsizei uniformCount,
+                                                const GLchar *const *uniformNames,
+                                                GLuint *uniformIndices);
+ANGLE_EXPORT void GL_APIENTRY GetUniformuiv(GLuint program, GLint location, GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY InvalidateFramebuffer(GLenum target,
+                                                    GLsizei numAttachments,
+                                                    const GLenum *attachments);
+ANGLE_EXPORT void GL_APIENTRY InvalidateSubFramebuffer(GLenum target,
+                                                       GLsizei numAttachments,
+                                                       const GLenum *attachments,
+                                                       GLint x,
+                                                       GLint y,
+                                                       GLsizei width,
+                                                       GLsizei height);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsQuery(GLuint id);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsSampler(GLuint sampler);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsSync(GLsync sync);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsTransformFeedback(GLuint id);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsVertexArray(GLuint array);
+ANGLE_EXPORT void *GL_APIENTRY MapBufferRange(GLenum target,
+                                              GLintptr offset,
+                                              GLsizeiptr length,
+                                              GLbitfield access);
+ANGLE_EXPORT void GL_APIENTRY PauseTransformFeedback();
+ANGLE_EXPORT void GL_APIENTRY ProgramBinary(GLuint program,
+                                            GLenum binaryFormat,
+                                            const void *binary,
+                                            GLsizei length);
+ANGLE_EXPORT void GL_APIENTRY ProgramParameteri(GLuint program, GLenum pname, GLint value);
+ANGLE_EXPORT void GL_APIENTRY ReadBuffer(GLenum src);
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageMultisample(GLenum target,
+                                                             GLsizei samples,
+                                                             GLenum internalformat,
+                                                             GLsizei width,
+                                                             GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY ResumeTransformFeedback();
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterfv(GLuint sampler,
+                                                 GLenum pname,
+                                                 const GLfloat *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameteri(GLuint sampler, GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY TexImage3D(GLenum target,
+                                         GLint level,
+                                         GLint internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type,
+                                         const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY
+TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY TexStorage3D(GLenum target,
+                                           GLsizei levels,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage3D(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TransformFeedbackVaryings(GLuint program,
+                                                        GLsizei count,
+                                                        const GLchar *const *varyings,
+                                                        GLenum bufferMode);
+ANGLE_EXPORT void GL_APIENTRY Uniform1ui(GLint location, GLuint v0);
+ANGLE_EXPORT void GL_APIENTRY Uniform1uiv(GLint location, GLsizei count, const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform2ui(GLint location, GLuint v0, GLuint v1);
+ANGLE_EXPORT void GL_APIENTRY Uniform2uiv(GLint location, GLsizei count, const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
+ANGLE_EXPORT void GL_APIENTRY Uniform3uiv(GLint location, GLsizei count, const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY
+Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ANGLE_EXPORT void GL_APIENTRY Uniform4uiv(GLint location, GLsizei count, const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY UniformBlockBinding(GLuint program,
+                                                  GLuint uniformBlockIndex,
+                                                  GLuint uniformBlockBinding);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix2x3fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix2x4fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix3x2fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix3x4fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix4x2fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix4x3fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT GLboolean GL_APIENTRY UnmapBuffer(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribDivisor(GLuint index, GLuint divisor);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4iv(GLuint index, const GLint *v);
+ANGLE_EXPORT void GL_APIENTRY
+VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4uiv(GLuint index, const GLuint *v);
+ANGLE_EXPORT void GL_APIENTRY
+VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
+}  // namespace gl
+
+#endif  // LIBGLESV2_ENTRY_POINTS_GLES_3_0_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.cpp
new file mode 100644
index 0000000000..e1848fdf70
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.cpp
@@ -0,0 +1,1380 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_3_1_autogen.cpp:
+//   Defines the GLES 3.1 entry points.
+
+#include "libGLESv2/entry_points_gles_3_1_autogen.h"
+
+#include "libANGLE/Context.h"
+#include "libANGLE/Context.inl.h"
+#include "libANGLE/capture_gles_3_1_autogen.h"
+#include "libANGLE/entry_points_utils.h"
+#include "libANGLE/validationES31.h"
+#include "libGLESv2/global_state.h"
+
+namespace gl
+{
+void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program)
+{
+    EVENT("(GLuint pipeline = %u, GLuint program = %u)", pipeline, program);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ActiveShaderProgram, context, pipeline, program);
+        if (context->skipValidation() || ValidateActiveShaderProgram(context, pipeline, program))
+        {
+            context->activeShaderProgram(pipeline, program);
+        }
+    }
+}
+
+void GL_APIENTRY BindImageTexture(GLuint unit,
+                                  GLuint texture,
+                                  GLint level,
+                                  GLboolean layered,
+                                  GLint layer,
+                                  GLenum access,
+                                  GLenum format)
+{
+    EVENT(
+        "(GLuint unit = %u, GLuint texture = %u, GLint level = %d, GLboolean layered = %u, GLint "
+        "layer = %d, GLenum access = 0x%X, GLenum format = 0x%X)",
+        unit, texture, level, layered, layer, access, format);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindImageTexture, context, unit, texture, level, layered, layer, access,
+                      format);
+        if (context->skipValidation() ||
+            ValidateBindImageTexture(context, unit, texture, level, layered, layer, access, format))
+        {
+            context->bindImageTexture(unit, texture, level, layered, layer, access, format);
+        }
+    }
+}
+
+void GL_APIENTRY BindProgramPipeline(GLuint pipeline)
+{
+    EVENT("(GLuint pipeline = %u)", pipeline);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindProgramPipeline, context, pipeline);
+        if (context->skipValidation() || ValidateBindProgramPipeline(context, pipeline))
+        {
+            context->bindProgramPipeline(pipeline);
+        }
+    }
+}
+
+void GL_APIENTRY BindVertexBuffer(GLuint bindingindex,
+                                  GLuint buffer,
+                                  GLintptr offset,
+                                  GLsizei stride)
+{
+    EVENT(
+        "(GLuint bindingindex = %u, GLuint buffer = %u, GLintptr offset = %llu, GLsizei stride = "
+        "%d)",
+        bindingindex, buffer, static_cast<unsigned long long>(offset), stride);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindVertexBuffer, context, bindingindex, buffer, offset, stride);
+        if (context->skipValidation() ||
+            ValidateBindVertexBuffer(context, bindingindex, buffer, offset, stride))
+        {
+            context->bindVertexBuffer(bindingindex, buffer, offset, stride);
+        }
+    }
+}
+
+GLuint GL_APIENTRY CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
+{
+    EVENT("(GLenum type = 0x%X, GLsizei count = %d, const GLchar *const*strings = 0x%016" PRIxPTR
+          ")",
+          type, count, (uintptr_t)strings);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ShaderType typePacked = FromGLenum<ShaderType>(type);
+        ANGLE_CAPTURE(CreateShaderProgramv, context, typePacked, count, strings);
+        if (context->skipValidation() ||
+            ValidateCreateShaderProgramv(context, typePacked, count, strings))
+        {
+            return context->createShaderProgramv(typePacked, count, strings);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
+}
+
+void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
+{
+    EVENT("(GLsizei n = %d, const GLuint *pipelines = 0x%016" PRIxPTR ")", n, (uintptr_t)pipelines);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteProgramPipelines, context, n, pipelines);
+        if (context->skipValidation() || ValidateDeleteProgramPipelines(context, n, pipelines))
+        {
+            context->deleteProgramPipelines(n, pipelines);
+        }
+    }
+}
+
+void GL_APIENTRY DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
+{
+    EVENT("(GLuint num_groups_x = %u, GLuint num_groups_y = %u, GLuint num_groups_z = %u)",
+          num_groups_x, num_groups_y, num_groups_z);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DispatchCompute, context, num_groups_x, num_groups_y, num_groups_z);
+        if (context->skipValidation() ||
+            ValidateDispatchCompute(context, num_groups_x, num_groups_y, num_groups_z))
+        {
+            context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+        }
+    }
+}
+
+void GL_APIENTRY DispatchComputeIndirect(GLintptr indirect)
+{
+    EVENT("(GLintptr indirect = %llu)", static_cast<unsigned long long>(indirect));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DispatchComputeIndirect, context, indirect);
+        if (context->skipValidation() || ValidateDispatchComputeIndirect(context, indirect))
+        {
+            context->dispatchComputeIndirect(indirect);
+        }
+    }
+}
+
+void GL_APIENTRY DrawArraysIndirect(GLenum mode, const void *indirect)
+{
+    EVENT("(GLenum mode = 0x%X, const void *indirect = 0x%016" PRIxPTR ")", mode,
+          (uintptr_t)indirect);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArraysIndirect, context, modePacked, indirect);
+        if (context->skipValidation() || ValidateDrawArraysIndirect(context, modePacked, indirect))
+        {
+            context->drawArraysIndirect(modePacked, indirect);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
+{
+    EVENT("(GLenum mode = 0x%X, GLenum type = 0x%X, const void *indirect = 0x%016" PRIxPTR ")",
+          mode, type, (uintptr_t)indirect);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElementsIndirect, context, modePacked, typePacked, indirect);
+        if (context->skipValidation() ||
+            ValidateDrawElementsIndirect(context, modePacked, typePacked, indirect))
+        {
+            context->drawElementsIndirect(modePacked, typePacked, indirect);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferParameteri(GLenum target, GLenum pname, GLint param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FramebufferParameteri, context, target, pname, param);
+        if (context->skipValidation() ||
+            ValidateFramebufferParameteri(context, target, pname, param))
+        {
+            context->framebufferParameteri(target, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines)
+{
+    EVENT("(GLsizei n = %d, GLuint *pipelines = 0x%016" PRIxPTR ")", n, (uintptr_t)pipelines);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenProgramPipelines, context, n, pipelines);
+        if (context->skipValidation() || ValidateGenProgramPipelines(context, n, pipelines))
+        {
+            context->genProgramPipelines(n, pipelines);
+        }
+    }
+}
+
+void GL_APIENTRY GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLboolean *data = 0x%016" PRIxPTR ")", target,
+          index, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetBooleani_v, context, target, index, data);
+        if (context->skipValidation() || ValidateGetBooleani_v(context, target, index, data))
+        {
+            context->getBooleani_v(target, index, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFramebufferParameteriv, context, target, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetFramebufferParameteriv(context, target, pname, params))
+        {
+            context->getFramebufferParameteriv(target, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
+{
+    EVENT("(GLenum pname = 0x%X, GLuint index = %u, GLfloat *val = 0x%016" PRIxPTR ")", pname,
+          index, (uintptr_t)val);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetMultisamplefv, context, pname, index, val);
+        if (context->skipValidation() || ValidateGetMultisamplefv(context, pname, index, val))
+        {
+            context->getMultisamplefv(pname, index, val);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramInterfaceiv(GLuint program,
+                                       GLenum programInterface,
+                                       GLenum pname,
+                                       GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, GLenum pname = 0x%X, GLint *params "
+        "= 0x%016" PRIxPTR ")",
+        program, programInterface, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramInterfaceiv, context, program, programInterface, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramInterfaceiv(context, program, programInterface, pname, params))
+        {
+            context->getProgramInterfaceiv(program, programInterface, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLchar *infoLog)
+{
+    EVENT("(GLuint pipeline = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *infoLog = 0x%016" PRIxPTR ")",
+          pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramPipelineInfoLog, context, pipeline, bufSize, length, infoLog);
+        if (context->skipValidation() ||
+            ValidateGetProgramPipelineInfoLog(context, pipeline, bufSize, length, infoLog))
+        {
+            context->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint pipeline = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")",
+          pipeline, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramPipelineiv, context, pipeline, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramPipelineiv(context, pipeline, pname, params))
+        {
+            context->getProgramPipelineiv(pipeline, pname, params);
+        }
+    }
+}
+
+GLuint GL_APIENTRY GetProgramResourceIndex(GLuint program,
+                                           GLenum programInterface,
+                                           const GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, const GLchar *name = 0x%016" PRIxPTR
+        ")",
+        program, programInterface, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramResourceIndex, context, program, programInterface, name);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceIndex(context, program, programInterface, name))
+        {
+            return context->getProgramResourceIndex(program, programInterface, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>();
+}
+
+GLint GL_APIENTRY GetProgramResourceLocation(GLuint program,
+                                             GLenum programInterface,
+                                             const GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, const GLchar *name = 0x%016" PRIxPTR
+        ")",
+        program, programInterface, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramResourceLocation, context, program, programInterface, name);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceLocation(context, program, programInterface, name))
+        {
+            return context->getProgramResourceLocation(program, programInterface, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>();
+}
+
+void GL_APIENTRY GetProgramResourceName(GLuint program,
+                                        GLenum programInterface,
+                                        GLuint index,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, GLuint index = %u, GLsizei bufSize "
+        "= %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR ")",
+        program, programInterface, index, bufSize, (uintptr_t)length, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramResourceName, context, program, programInterface, index, bufSize,
+                      length, name);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceName(context, program, programInterface, index, bufSize,
+                                           length, name))
+        {
+            context->getProgramResourceName(program, programInterface, index, bufSize, length,
+                                            name);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramResourceiv(GLuint program,
+                                      GLenum programInterface,
+                                      GLuint index,
+                                      GLsizei propCount,
+                                      const GLenum *props,
+                                      GLsizei bufSize,
+                                      GLsizei *length,
+                                      GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, GLuint index = %u, GLsizei "
+        "propCount = %d, const GLenum *props = 0x%016" PRIxPTR
+        ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+        ", GLint *params = 0x%016" PRIxPTR ")",
+        program, programInterface, index, propCount, (uintptr_t)props, bufSize, (uintptr_t)length,
+        (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramResourceiv, context, program, programInterface, index, propCount,
+                      props, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceiv(context, program, programInterface, index, propCount,
+                                         props, bufSize, length, params))
+        {
+            context->getProgramResourceiv(program, programInterface, index, propCount, props,
+                                          bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLfloat *params = "
+        "0x%016" PRIxPTR ")",
+        target, level, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterfv, context, targetPacked, level, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterfv(context, targetPacked, level, pname, params))
+        {
+            context->getTexLevelParameterfv(targetPacked, level, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        target, level, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameteriv, context, targetPacked, level, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameteriv(context, targetPacked, level, pname, params))
+        {
+            context->getTexLevelParameteriv(targetPacked, level, pname, params);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsProgramPipeline(GLuint pipeline)
+{
+    EVENT("(GLuint pipeline = %u)", pipeline);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsProgramPipeline, context, pipeline);
+        if (context->skipValidation() || ValidateIsProgramPipeline(context, pipeline))
+        {
+            return context->isProgramPipeline(pipeline);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
+}
+
+void GL_APIENTRY MemoryBarrier(GLbitfield barriers)
+{
+    EVENT("(GLbitfield barriers = 0x%X)", barriers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MemoryBarrier, context, barriers);
+        if (context->skipValidation() || ValidateMemoryBarrier(context, barriers))
+        {
+            context->memoryBarrier(barriers);
+        }
+    }
+}
+
+void GL_APIENTRY MemoryBarrierByRegion(GLbitfield barriers)
+{
+    EVENT("(GLbitfield barriers = 0x%X)", barriers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MemoryBarrierByRegion, context, barriers);
+        if (context->skipValidation() || ValidateMemoryBarrierByRegion(context, barriers))
+        {
+            context->memoryBarrierByRegion(barriers);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLfloat v0 = %f)", program, location, v0);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform1f, context, program, location, v0);
+        if (context->skipValidation() || ValidateProgramUniform1f(context, program, location, v0))
+        {
+            context->programUniform1f(program, location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1fv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform1fv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform1fv(context, program, location, count, value))
+        {
+            context->programUniform1fv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1i(GLuint program, GLint location, GLint v0)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d)", program, location, v0);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform1i, context, program, location, v0);
+        if (context->skipValidation() || ValidateProgramUniform1i(context, program, location, v0))
+        {
+            context->programUniform1i(program, location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1iv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform1iv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform1iv(context, program, location, count, value))
+        {
+            context->programUniform1iv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLuint v0 = %u)", program, location, v0);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform1ui, context, program, location, v0);
+        if (context->skipValidation() || ValidateProgramUniform1ui(context, program, location, v0))
+        {
+            context->programUniform1ui(program, location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1uiv(GLuint program,
+                                    GLint location,
+                                    GLsizei count,
+                                    const GLuint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform1uiv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform1uiv(context, program, location, count, value))
+        {
+            context->programUniform1uiv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f)", program,
+          location, v0, v1);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform2f, context, program, location, v0, v1);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2f(context, program, location, v0, v1))
+        {
+            context->programUniform2f(program, location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2fv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform2fv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2fv(context, program, location, count, value))
+        {
+            context->programUniform2fv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d)", program,
+          location, v0, v1);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform2i, context, program, location, v0, v1);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2i(context, program, location, v0, v1))
+        {
+            context->programUniform2i(program, location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2iv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform2iv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2iv(context, program, location, count, value))
+        {
+            context->programUniform2iv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u)", program,
+          location, v0, v1);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform2ui, context, program, location, v0, v1);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2ui(context, program, location, v0, v1))
+        {
+            context->programUniform2ui(program, location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2uiv(GLuint program,
+                                    GLint location,
+                                    GLsizei count,
+                                    const GLuint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform2uiv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2uiv(context, program, location, count, value))
+        {
+            context->programUniform2uiv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
+        "%f)",
+        program, location, v0, v1, v2);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform3f, context, program, location, v0, v1, v2);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3f(context, program, location, v0, v1, v2))
+        {
+            context->programUniform3f(program, location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3fv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform3fv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3fv(context, program, location, count, value))
+        {
+            context->programUniform3fv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d)",
+          program, location, v0, v1, v2);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform3i, context, program, location, v0, v1, v2);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3i(context, program, location, v0, v1, v2))
+        {
+            context->programUniform3i(program, location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3iv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform3iv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3iv(context, program, location, count, value))
+        {
+            context->programUniform3iv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
+        "%u)",
+        program, location, v0, v1, v2);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform3ui, context, program, location, v0, v1, v2);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3ui(context, program, location, v0, v1, v2))
+        {
+            context->programUniform3ui(program, location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3uiv(GLuint program,
+                                    GLint location,
+                                    GLsizei count,
+                                    const GLuint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform3uiv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3uiv(context, program, location, count, value))
+        {
+            context->programUniform3uiv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
+        "%f, GLfloat v3 = %f)",
+        program, location, v0, v1, v2, v3);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform4f, context, program, location, v0, v1, v2, v3);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4f(context, program, location, v0, v1, v2, v3))
+        {
+            context->programUniform4f(program, location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4fv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform4fv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4fv(context, program, location, count, value))
+        {
+            context->programUniform4fv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, "
+        "GLint v3 = %d)",
+        program, location, v0, v1, v2, v3);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform4i, context, program, location, v0, v1, v2, v3);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4i(context, program, location, v0, v1, v2, v3))
+        {
+            context->programUniform4i(program, location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4iv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform4iv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4iv(context, program, location, count, value))
+        {
+            context->programUniform4iv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
+        "%u, GLuint v3 = %u)",
+        program, location, v0, v1, v2, v3);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform4ui, context, program, location, v0, v1, v2, v3);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4ui(context, program, location, v0, v1, v2, v3))
+        {
+            context->programUniform4ui(program, location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4uiv(GLuint program,
+                                    GLint location,
+                                    GLsizei count,
+                                    const GLuint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniform4uiv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4uiv(context, program, location, count, value))
+        {
+            context->programUniform4uiv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix2fv(GLuint program,
+                                         GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix2fv, context, program, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix2fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix2fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix2x3fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix2x3fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix2x3fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix2x4fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix2x4fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program,
+                                         GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix3fv, context, program, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix3fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix3fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix3x2fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix3x2fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix3x4fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix3x4fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix3x4fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
+                                         GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix4fv, context, program, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix4fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix4fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix4x2fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix4x2fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix4x3fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix4x3fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY SampleMaski(GLuint maskNumber, GLbitfield mask)
+{
+    EVENT("(GLuint maskNumber = %u, GLbitfield mask = 0x%X)", maskNumber, mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SampleMaski, context, maskNumber, mask);
+        if (context->skipValidation() || ValidateSampleMaski(context, maskNumber, mask))
+        {
+            context->sampleMaski(maskNumber, mask);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage2DMultisample(GLenum target,
+                                         GLsizei samples,
+                                         GLenum internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLboolean fixedsamplelocations)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLboolean fixedsamplelocations = %u)",
+        target, samples, internalformat, width, height, fixedsamplelocations);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage2DMultisample, context, targetPacked, samples, internalformat,
+                      width, height, fixedsamplelocations);
+        if (context->skipValidation() ||
+            ValidateTexStorage2DMultisample(context, targetPacked, samples, internalformat, width,
+                                            height, fixedsamplelocations))
+        {
+            context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
+                                             fixedsamplelocations);
+        }
+    }
+}
+
+void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
+{
+    EVENT("(GLuint pipeline = %u, GLbitfield stages = 0x%X, GLuint program = %u)", pipeline, stages,
+          program);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(UseProgramStages, context, pipeline, stages, program);
+        if (context->skipValidation() ||
+            ValidateUseProgramStages(context, pipeline, stages, program))
+        {
+            context->useProgramStages(pipeline, stages, program);
+        }
+    }
+}
+
+void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline)
+{
+    EVENT("(GLuint pipeline = %u)", pipeline);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ValidateProgramPipeline, context, pipeline);
+        if (context->skipValidation() || ValidateValidateProgramPipeline(context, pipeline))
+        {
+            context->validateProgramPipeline(pipeline);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribBinding(GLuint attribindex, GLuint bindingindex)
+{
+    EVENT("(GLuint attribindex = %u, GLuint bindingindex = %u)", attribindex, bindingindex);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttribBinding, context, attribindex, bindingindex);
+        if (context->skipValidation() ||
+            ValidateVertexAttribBinding(context, attribindex, bindingindex))
+        {
+            context->vertexAttribBinding(attribindex, bindingindex);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribFormat(GLuint attribindex,
+                                    GLint size,
+                                    GLenum type,
+                                    GLboolean normalized,
+                                    GLuint relativeoffset)
+{
+    EVENT(
+        "(GLuint attribindex = %u, GLint size = %d, GLenum type = 0x%X, GLboolean normalized = %u, "
+        "GLuint relativeoffset = %u)",
+        attribindex, size, type, normalized, relativeoffset);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexAttribFormat, context, attribindex, size, typePacked, normalized,
+                      relativeoffset);
+        if (context->skipValidation() ||
+            ValidateVertexAttribFormat(context, attribindex, size, typePacked, normalized,
+                                       relativeoffset))
+        {
+            context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribIFormat(GLuint attribindex,
+                                     GLint size,
+                                     GLenum type,
+                                     GLuint relativeoffset)
+{
+    EVENT(
+        "(GLuint attribindex = %u, GLint size = %d, GLenum type = 0x%X, GLuint relativeoffset = "
+        "%u)",
+        attribindex, size, type, relativeoffset);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexAttribIFormat, context, attribindex, size, typePacked, relativeoffset);
+        if (context->skipValidation() ||
+            ValidateVertexAttribIFormat(context, attribindex, size, typePacked, relativeoffset))
+        {
+            context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset);
+        }
+    }
+}
+
+void GL_APIENTRY VertexBindingDivisor(GLuint bindingindex, GLuint divisor)
+{
+    EVENT("(GLuint bindingindex = %u, GLuint divisor = %u)", bindingindex, divisor);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexBindingDivisor, context, bindingindex, divisor);
+        if (context->skipValidation() ||
+            ValidateVertexBindingDivisor(context, bindingindex, divisor))
+        {
+            context->vertexBindingDivisor(bindingindex, divisor);
+        }
+    }
+}
+}  // namespace gl
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.h
new file mode 100644
index 0000000000..bdb4905133
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.h
@@ -0,0 +1,227 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_3_1_autogen.h:
+//   Defines the GLES 3.1 entry points.
+
+#ifndef LIBGLESV2_ENTRY_POINTS_GLES_3_1_AUTOGEN_H_
+#define LIBGLESV2_ENTRY_POINTS_GLES_3_1_AUTOGEN_H_
+
+#include <GLES3/gl31.h>
+#include <export.h>
+#include "common/platform.h"
+
+namespace gl
+{
+ANGLE_EXPORT void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program);
+ANGLE_EXPORT void GL_APIENTRY BindImageTexture(GLuint unit,
+                                               GLuint texture,
+                                               GLint level,
+                                               GLboolean layered,
+                                               GLint layer,
+                                               GLenum access,
+                                               GLenum format);
+ANGLE_EXPORT void GL_APIENTRY BindProgramPipeline(GLuint pipeline);
+ANGLE_EXPORT void GL_APIENTRY BindVertexBuffer(GLuint bindingindex,
+                                               GLuint buffer,
+                                               GLintptr offset,
+                                               GLsizei stride);
+ANGLE_EXPORT GLuint GL_APIENTRY CreateShaderProgramv(GLenum type,
+                                                     GLsizei count,
+                                                     const GLchar *const *strings);
+ANGLE_EXPORT void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
+ANGLE_EXPORT void GL_APIENTRY DispatchCompute(GLuint num_groups_x,
+                                              GLuint num_groups_y,
+                                              GLuint num_groups_z);
+ANGLE_EXPORT void GL_APIENTRY DispatchComputeIndirect(GLintptr indirect);
+ANGLE_EXPORT void GL_APIENTRY DrawArraysIndirect(GLenum mode, const void *indirect);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
+ANGLE_EXPORT void GL_APIENTRY FramebufferParameteri(GLenum target, GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines);
+ANGLE_EXPORT void GL_APIENTRY GetBooleani_v(GLenum target, GLuint index, GLboolean *data);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
+ANGLE_EXPORT void GL_APIENTRY GetProgramInterfaceiv(GLuint program,
+                                                    GLenum programInterface,
+                                                    GLenum pname,
+                                                    GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLchar *infoLog);
+ANGLE_EXPORT void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
+ANGLE_EXPORT GLuint GL_APIENTRY GetProgramResourceIndex(GLuint program,
+                                                        GLenum programInterface,
+                                                        const GLchar *name);
+ANGLE_EXPORT GLint GL_APIENTRY GetProgramResourceLocation(GLuint program,
+                                                          GLenum programInterface,
+                                                          const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetProgramResourceName(GLuint program,
+                                                     GLenum programInterface,
+                                                     GLuint index,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetProgramResourceiv(GLuint program,
+                                                   GLenum programInterface,
+                                                   GLuint index,
+                                                   GLsizei propCount,
+                                                   const GLenum *props,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfv(GLenum target,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameteriv(GLenum target,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLint *params);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsProgramPipeline(GLuint pipeline);
+ANGLE_EXPORT void GL_APIENTRY MemoryBarrier(GLbitfield barriers);
+ANGLE_EXPORT void GL_APIENTRY MemoryBarrierByRegion(GLbitfield barriers);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1fv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1i(GLuint program, GLint location, GLint v0);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1iv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1ui(GLuint program, GLint location, GLuint v0);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1uiv(GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2f(GLuint program,
+                                               GLint location,
+                                               GLfloat v0,
+                                               GLfloat v1);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2fv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2iv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2ui(GLuint program,
+                                                GLint location,
+                                                GLuint v0,
+                                                GLuint v1);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2uiv(GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3fv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3iv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3uiv(GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4fv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4iv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4uiv(GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2fv(GLuint program,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      GLboolean transpose,
+                                                      const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2x3fv(GLuint program,
+                                                        GLint location,
+                                                        GLsizei count,
+                                                        GLboolean transpose,
+                                                        const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
+                                                        GLint location,
+                                                        GLsizei count,
+                                                        GLboolean transpose,
+                                                        const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      GLboolean transpose,
+                                                      const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
+                                                        GLint location,
+                                                        GLsizei count,
+                                                        GLboolean transpose,
+                                                        const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3x4fv(GLuint program,
+                                                        GLint location,
+                                                        GLsizei count,
+                                                        GLboolean transpose,
+                                                        const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      GLboolean transpose,
+                                                      const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
+                                                        GLint location,
+                                                        GLsizei count,
+                                                        GLboolean transpose,
+                                                        const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program,
+                                                        GLint location,
+                                                        GLsizei count,
+                                                        GLboolean transpose,
+                                                        const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY SampleMaski(GLuint maskNumber, GLbitfield mask);
+ANGLE_EXPORT void GL_APIENTRY TexStorage2DMultisample(GLenum target,
+                                                      GLsizei samples,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLboolean fixedsamplelocations);
+ANGLE_EXPORT void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
+ANGLE_EXPORT void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribBinding(GLuint attribindex, GLuint bindingindex);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribFormat(GLuint attribindex,
+                                                 GLint size,
+                                                 GLenum type,
+                                                 GLboolean normalized,
+                                                 GLuint relativeoffset);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribIFormat(GLuint attribindex,
+                                                  GLint size,
+                                                  GLenum type,
+                                                  GLuint relativeoffset);
+ANGLE_EXPORT void GL_APIENTRY VertexBindingDivisor(GLuint bindingindex, GLuint divisor);
+}  // namespace gl
+
+#endif  // LIBGLESV2_ENTRY_POINTS_GLES_3_1_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.cpp
new file mode 100644
index 0000000000..043634e01d
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.cpp
@@ -0,0 +1,19759 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_ext_autogen.cpp:
+//   Defines the GLES extension entry points.
+
+#include "libGLESv2/entry_points_gles_ext_autogen.h"
+
+#include "libANGLE/Context.h"
+#include "libANGLE/Context.inl.h"
+#include "libANGLE/capture_gles_ext_autogen.h"
+#include "libANGLE/entry_points_utils.h"
+#include "libANGLE/validationESEXT.h"
+#include "libGLESv2/global_state.h"
+
+#include "libANGLE/capture_gles_1_0_autogen.h"
+#include "libANGLE/capture_gles_2_0_autogen.h"
+#include "libANGLE/capture_gles_3_0_autogen.h"
+#include "libANGLE/capture_gles_3_1_autogen.h"
+#include "libANGLE/validationES1.h"
+#include "libANGLE/validationES2.h"
+#include "libANGLE/validationES3.h"
+#include "libANGLE/validationES31.h"
+
+namespace gl
+{
+
+// GL_ANGLE_copy_texture_3d
+void GL_APIENTRY CopyTexture3DANGLE(GLuint sourceId,
+                                    GLint sourceLevel,
+                                    GLenum destTarget,
+                                    GLuint destId,
+                                    GLint destLevel,
+                                    GLint internalFormat,
+                                    GLenum destType,
+                                    GLboolean unpackFlipY,
+                                    GLboolean unpackPremultiplyAlpha,
+                                    GLboolean unpackUnmultiplyAlpha)
+{
+    EVENT(
+        "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
+        "%u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = 0x%X, GLboolean "
+        "unpackFlipY = %u, GLboolean unpackPremultiplyAlpha = %u, GLboolean unpackUnmultiplyAlpha "
+        "= %u)",
+        sourceId, sourceLevel, destTarget, destId, destLevel, internalFormat, destType, unpackFlipY,
+        unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget destTargetPacked = FromGLenum<TextureTarget>(destTarget);
+        ANGLE_CAPTURE(CopyTexture3DANGLE, context, sourceId, sourceLevel, destTargetPacked, destId,
+                      destLevel, internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                      unpackUnmultiplyAlpha);
+        if (context->skipValidation() ||
+            ValidateCopyTexture3DANGLE(context, sourceId, sourceLevel, destTargetPacked, destId,
+                                       destLevel, internalFormat, destType, unpackFlipY,
+                                       unpackPremultiplyAlpha, unpackUnmultiplyAlpha))
+        {
+            context->copyTexture3D(sourceId, sourceLevel, destTargetPacked, destId, destLevel,
+                                   internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                                   unpackUnmultiplyAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY CopySubTexture3DANGLE(GLuint sourceId,
+                                       GLint sourceLevel,
+                                       GLenum destTarget,
+                                       GLuint destId,
+                                       GLint destLevel,
+                                       GLint xoffset,
+                                       GLint yoffset,
+                                       GLint zoffset,
+                                       GLint x,
+                                       GLint y,
+                                       GLint z,
+                                       GLint width,
+                                       GLint height,
+                                       GLint depth,
+                                       GLboolean unpackFlipY,
+                                       GLboolean unpackPremultiplyAlpha,
+                                       GLboolean unpackUnmultiplyAlpha)
+{
+    EVENT(
+        "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
+        "%u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint zoffset = %d, "
+        "GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height = %d, GLint "
+        "depth = %d, GLboolean unpackFlipY = %u, GLboolean unpackPremultiplyAlpha = %u, GLboolean "
+        "unpackUnmultiplyAlpha = %u)",
+        sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, zoffset, x, y, z,
+        width, height, depth, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget destTargetPacked = FromGLenum<TextureTarget>(destTarget);
+        ANGLE_CAPTURE(CopySubTexture3DANGLE, context, sourceId, sourceLevel, destTargetPacked,
+                      destId, destLevel, xoffset, yoffset, zoffset, x, y, z, width, height, depth,
+                      unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+        if (context->skipValidation() ||
+            ValidateCopySubTexture3DANGLE(context, sourceId, sourceLevel, destTargetPacked, destId,
+                                          destLevel, xoffset, yoffset, zoffset, x, y, z, width,
+                                          height, depth, unpackFlipY, unpackPremultiplyAlpha,
+                                          unpackUnmultiplyAlpha))
+        {
+            context->copySubTexture3D(sourceId, sourceLevel, destTargetPacked, destId, destLevel,
+                                      xoffset, yoffset, zoffset, x, y, z, width, height, depth,
+                                      unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+        }
+    }
+}
+
+// GL_ANGLE_framebuffer_blit
+void GL_APIENTRY BlitFramebufferANGLE(GLint srcX0,
+                                      GLint srcY0,
+                                      GLint srcX1,
+                                      GLint srcY1,
+                                      GLint dstX0,
+                                      GLint dstY0,
+                                      GLint dstX1,
+                                      GLint dstY1,
+                                      GLbitfield mask,
+                                      GLenum filter)
+{
+    EVENT(
+        "(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, GLint dstX0 = "
+        "%d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask = 0x%X, GLenum "
+        "filter = 0x%X)",
+        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BlitFramebufferANGLE, context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+                      dstX1, dstY1, mask, filter);
+        if (context->skipValidation() ||
+            ValidateBlitFramebufferANGLE(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
+                                         dstY1, mask, filter))
+        {
+            context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
+                                     filter);
+        }
+    }
+}
+
+// GL_ANGLE_framebuffer_multisample
+void GL_APIENTRY RenderbufferStorageMultisampleANGLE(GLenum target,
+                                                     GLsizei samples,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d)",
+        target, samples, internalformat, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(RenderbufferStorageMultisampleANGLE, context, target, samples, internalformat,
+                      width, height);
+        if (context->skipValidation() ||
+            ValidateRenderbufferStorageMultisampleANGLE(context, target, samples, internalformat,
+                                                        width, height))
+        {
+            context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
+        }
+    }
+}
+
+// GL_ANGLE_instanced_arrays
+void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode,
+                                          GLint first,
+                                          GLsizei count,
+                                          GLsizei primcount)
+{
+    EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei primcount = %d)",
+          mode, first, count, primcount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArraysInstancedANGLE, context, modePacked, first, count, primcount);
+        if (context->skipValidation() ||
+            ValidateDrawArraysInstancedANGLE(context, modePacked, first, count, primcount))
+        {
+            context->drawArraysInstanced(modePacked, first, count, primcount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode,
+                                            GLsizei count,
+                                            GLenum type,
+                                            const void *indices,
+                                            GLsizei primcount)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = "
+        "0x%016" PRIxPTR ", GLsizei primcount = %d)",
+        mode, count, type, (uintptr_t)indices, primcount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElementsInstancedANGLE, context, modePacked, count, typePacked, indices,
+                      primcount);
+        if (context->skipValidation() ||
+            ValidateDrawElementsInstancedANGLE(context, modePacked, count, typePacked, indices,
+                                               primcount))
+        {
+            context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribDivisorANGLE(GLuint index, GLuint divisor)
+{
+    EVENT("(GLuint index = %u, GLuint divisor = %u)", index, divisor);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttribDivisorANGLE, context, index, divisor);
+        if (context->skipValidation() || ValidateVertexAttribDivisorANGLE(context, index, divisor))
+        {
+            context->vertexAttribDivisor(index, divisor);
+        }
+    }
+}
+
+// GL_ANGLE_multi_draw
+void GL_APIENTRY MultiDrawArraysANGLE(GLenum mode,
+                                      const GLint *firsts,
+                                      const GLsizei *counts,
+                                      GLsizei drawcount)
+{
+    EVENT("(GLenum mode = 0x%X, const GLint *firsts = 0x%016" PRIxPTR
+          ", const GLsizei *counts = 0x%016" PRIxPTR ", GLsizei drawcount = %d)",
+          mode, (uintptr_t)firsts, (uintptr_t)counts, drawcount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(MultiDrawArraysANGLE, context, modePacked, firsts, counts, drawcount);
+        if (context->skipValidation() ||
+            ValidateMultiDrawArraysANGLE(context, modePacked, firsts, counts, drawcount))
+        {
+            context->multiDrawArrays(modePacked, firsts, counts, drawcount);
+        }
+    }
+}
+
+void GL_APIENTRY MultiDrawArraysInstancedANGLE(GLenum mode,
+                                               const GLint *firsts,
+                                               const GLsizei *counts,
+                                               const GLsizei *instanceCounts,
+                                               GLsizei drawcount)
+{
+    EVENT("(GLenum mode = 0x%X, const GLint *firsts = 0x%016" PRIxPTR
+          ", const GLsizei *counts = 0x%016" PRIxPTR
+          ", const GLsizei *instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d)",
+          mode, (uintptr_t)firsts, (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(MultiDrawArraysInstancedANGLE, context, modePacked, firsts, counts,
+                      instanceCounts, drawcount);
+        if (context->skipValidation() ||
+            ValidateMultiDrawArraysInstancedANGLE(context, modePacked, firsts, counts,
+                                                  instanceCounts, drawcount))
+        {
+            context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts,
+                                              drawcount);
+        }
+    }
+}
+
+void GL_APIENTRY MultiDrawElementsANGLE(GLenum mode,
+                                        const GLsizei *counts,
+                                        GLenum type,
+                                        const GLvoid *const *indices,
+                                        GLsizei drawcount)
+{
+    EVENT("(GLenum mode = 0x%X, const GLsizei *counts = 0x%016" PRIxPTR
+          ", GLenum type = 0x%X, const GLvoid *const*indices = 0x%016" PRIxPTR
+          ", GLsizei drawcount = %d)",
+          mode, (uintptr_t)counts, type, (uintptr_t)indices, drawcount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(MultiDrawElementsANGLE, context, modePacked, counts, typePacked, indices,
+                      drawcount);
+        if (context->skipValidation() ||
+            ValidateMultiDrawElementsANGLE(context, modePacked, counts, typePacked, indices,
+                                           drawcount))
+        {
+            context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount);
+        }
+    }
+}
+
+void GL_APIENTRY MultiDrawElementsInstancedANGLE(GLenum mode,
+                                                 const GLsizei *counts,
+                                                 GLenum type,
+                                                 const GLvoid *const *indices,
+                                                 const GLsizei *instanceCounts,
+                                                 GLsizei drawcount)
+{
+    EVENT("(GLenum mode = 0x%X, const GLsizei *counts = 0x%016" PRIxPTR
+          ", GLenum type = 0x%X, const GLvoid *const*indices = 0x%016" PRIxPTR
+          ", const GLsizei*instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d)",
+          mode, (uintptr_t)counts, type, (uintptr_t)indices, (uintptr_t)instanceCounts, drawcount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(MultiDrawElementsInstancedANGLE, context, modePacked, counts, typePacked,
+                      indices, instanceCounts, drawcount);
+        if (context->skipValidation() ||
+            ValidateMultiDrawElementsInstancedANGLE(context, modePacked, counts, typePacked,
+                                                    indices, instanceCounts, drawcount))
+        {
+            context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices,
+                                                instanceCounts, drawcount);
+        }
+    }
+}
+
+// GL_ANGLE_provoking_vertex
+void GL_APIENTRY ProvokingVertexANGLE(GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ProvokingVertexConvention modePacked = FromGLenum<ProvokingVertexConvention>(mode);
+        ANGLE_CAPTURE(ProvokingVertexANGLE, context, modePacked);
+        if (context->skipValidation() || ValidateProvokingVertexANGLE(context, modePacked))
+        {
+            context->provokingVertex(modePacked);
+        }
+    }
+}
+
+// GL_ANGLE_request_extension
+void GL_APIENTRY RequestExtensionANGLE(const GLchar *name)
+{
+    EVENT("(const GLchar * name = 0x%016" PRIxPTR ")", (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(RequestExtensionANGLE, context, name);
+        if (context->skipValidation() || ValidateRequestExtensionANGLE(context, name))
+        {
+            context->requestExtension(name);
+        }
+    }
+}
+
+// GL_ANGLE_robust_client_memory
+void GL_APIENTRY GetBooleanvRobustANGLE(GLenum pname,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLboolean *params)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", GLboolean * params = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetBooleanvRobustANGLE, context, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetBooleanvRobustANGLE(context, pname, bufSize, length, params))
+        {
+            context->getBooleanvRobust(pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferParameterivRobustANGLE(GLenum target,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferParameterivRobustANGLE, context, targetPacked, pname, bufSize,
+                      length, params);
+        if (context->skipValidation() || ValidateGetBufferParameterivRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFloatvRobustANGLE(GLenum pname,
+                                      GLsizei bufSize,
+                                      GLsizei *length,
+                                      GLfloat *params)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", GLfloat * params = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFloatvRobustANGLE, context, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetFloatvRobustANGLE(context, pname, bufSize, length, params))
+        {
+            context->getFloatvRobust(pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
+                                                                GLenum attachment,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = "
+        "%d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, attachment, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFramebufferAttachmentParameterivRobustANGLE, context, target, attachment,
+                      pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetFramebufferAttachmentParameterivRobustANGLE(context, target, attachment,
+                                                                   pname, bufSize, length, params))
+        {
+            context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize,
+                                                               length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetIntegervRobustANGLE(GLenum pname, GLsizei bufSize, GLsizei *length, GLint *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", GLint * data = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetIntegervRobustANGLE, context, pname, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetIntegervRobustANGLE(context, pname, bufSize, length, data))
+        {
+            context->getIntegervRobust(pname, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramivRobustANGLE(GLuint program,
+                                         GLenum pname,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramivRobustANGLE, context, program, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramivRobustANGLE(context, program, pname, bufSize, length, params))
+        {
+            context->getProgramivRobust(program, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetRenderbufferParameterivRobustANGLE(GLenum target,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetRenderbufferParameterivRobustANGLE, context, target, pname, bufSize,
+                      length, params);
+        if (context->skipValidation() || ValidateGetRenderbufferParameterivRobustANGLE(
+                                             context, target, pname, bufSize, length, params))
+        {
+            context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY
+GetShaderivRobustANGLE(GLuint shader, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params)
+{
+    EVENT(
+        "(GLuint shader = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        shader, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetShaderivRobustANGLE, context, shader, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetShaderivRobustANGLE(context, shader, pname, bufSize, length, params))
+        {
+            context->getShaderivRobust(shader, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterfvRobustANGLE(GLenum target,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterfvRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetTexParameterfvRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterivRobustANGLE(GLenum target,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterivRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetTexParameterivRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformfvRobustANGLE(GLuint program,
+                                         GLint location,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLfloat *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformfvRobustANGLE, context, program, location, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetUniformfvRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getUniformfvRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformivRobustANGLE(GLuint program,
+                                         GLint location,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformivRobustANGLE, context, program, location, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetUniformivRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getUniformivRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribfvRobustANGLE(GLuint index,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLfloat *params)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribfvRobustANGLE, context, index, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribfvRobustANGLE(context, index, pname, bufSize, length, params))
+        {
+            context->getVertexAttribfvRobust(index, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribivRobustANGLE(GLuint index,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLint *params)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribivRobustANGLE, context, index, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribivRobustANGLE(context, index, pname, bufSize, length, params))
+        {
+            context->getVertexAttribivRobust(index, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribPointervRobustANGLE(GLuint index,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    void **pointer)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", void ** pointer = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribPointervRobustANGLE, context, index, pname, bufSize, length,
+                      pointer);
+        if (context->skipValidation() || ValidateGetVertexAttribPointervRobustANGLE(
+                                             context, index, pname, bufSize, length, pointer))
+        {
+            context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY ReadPixelsRobustANGLE(GLint x,
+                                       GLint y,
+                                       GLsizei width,
+                                       GLsizei height,
+                                       GLenum format,
+                                       GLenum type,
+                                       GLsizei bufSize,
+                                       GLsizei *length,
+                                       GLsizei *columns,
+                                       GLsizei *rows,
+                                       void *pixels)
+{
+    EVENT(
+        "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = "
+        "0x%X, GLenum type = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+        ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR
+        ", void * pixels = 0x%016" PRIxPTR ")",
+        x, y, width, height, format, type, bufSize, (uintptr_t)length, (uintptr_t)columns,
+        (uintptr_t)rows, (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ReadPixelsRobustANGLE, context, x, y, width, height, format, type, bufSize,
+                      length, columns, rows, pixels);
+        if (context->skipValidation() ||
+            ValidateReadPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
+                                          length, columns, rows, pixels))
+        {
+            context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
+                                      rows, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage2DRobustANGLE(GLenum target,
+                                       GLint level,
+                                       GLint internalformat,
+                                       GLsizei width,
+                                       GLsizei height,
+                                       GLint border,
+                                       GLenum format,
+                                       GLenum type,
+                                       GLsizei bufSize,
+                                       const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, GLsizei "
+        "bufSize = %d, const void * pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, border, format, type, bufSize,
+        (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage2DRobustANGLE, context, targetPacked, level, internalformat, width,
+                      height, border, format, type, bufSize, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage2DRobustANGLE(context, targetPacked, level, internalformat, width,
+                                          height, border, format, type, bufSize, pixels))
+        {
+            context->texImage2DRobust(targetPacked, level, internalformat, width, height, border,
+                                      format, type, bufSize, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterfvRobustANGLE(GLenum target,
+                                           GLenum pname,
+                                           GLsizei bufSize,
+                                           const GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLfloat * params "
+        "= 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterfvRobustANGLE, context, targetPacked, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterfvRobustANGLE(context, targetPacked, pname, bufSize, params))
+        {
+            context->texParameterfvRobust(targetPacked, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterivRobustANGLE(GLenum target,
+                                           GLenum pname,
+                                           GLsizei bufSize,
+                                           const GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLint * params = "
+        "0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterivRobustANGLE, context, targetPacked, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterivRobustANGLE(context, targetPacked, pname, bufSize, params))
+        {
+            context->texParameterivRobust(targetPacked, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage2DRobustANGLE(GLenum target,
+                                          GLint level,
+                                          GLint xoffset,
+                                          GLint yoffset,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei "
+        "width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, GLsizei "
+        "bufSize = %d, const void * pixels = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, width, height, format, type, bufSize, (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage2DRobustANGLE, context, targetPacked, level, xoffset, yoffset,
+                      width, height, format, type, bufSize, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage2DRobustANGLE(context, targetPacked, level, xoffset, yoffset, width,
+                                             height, format, type, bufSize, pixels))
+        {
+            context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height,
+                                         format, type, bufSize, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage3DRobustANGLE(GLenum target,
+                                       GLint level,
+                                       GLint internalformat,
+                                       GLsizei width,
+                                       GLsizei height,
+                                       GLsizei depth,
+                                       GLint border,
+                                       GLenum format,
+                                       GLenum type,
+                                       GLsizei bufSize,
+                                       const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, GLenum "
+        "type = 0x%X, GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, format, type, bufSize,
+        (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage3DRobustANGLE, context, targetPacked, level, internalformat, width,
+                      height, depth, border, format, type, bufSize, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage3DRobustANGLE(context, targetPacked, level, internalformat, width,
+                                          height, depth, border, format, type, bufSize, pixels))
+        {
+            context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth,
+                                      border, format, type, bufSize, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage3DRobustANGLE(GLenum target,
+                                          GLint level,
+                                          GLint xoffset,
+                                          GLint yoffset,
+                                          GLint zoffset,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLsizei depth,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLenum type = 0x%X, GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR
+        ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize,
+        (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage3DRobustANGLE, context, targetPacked, level, xoffset, yoffset,
+                      zoffset, width, height, depth, format, type, bufSize, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage3DRobustANGLE(context, targetPacked, level, xoffset, yoffset,
+                                             zoffset, width, height, depth, format, type, bufSize,
+                                             pixels))
+        {
+            context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width,
+                                         height, depth, format, type, bufSize, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexImage2DRobustANGLE(GLenum target,
+                                                 GLint level,
+                                                 GLenum internalformat,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLint border,
+                                                 GLsizei imageSize,
+                                                 GLsizei dataSize,
+                                                 const GLvoid *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, GLsizei dataSize = "
+        "%d, const GLvoid * data = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, border, imageSize, dataSize, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage2DRobustANGLE, context, targetPacked, level, internalformat,
+                      width, height, border, imageSize, dataSize, data);
+        if (context->skipValidation() || ValidateCompressedTexImage2DRobustANGLE(
+                                             context, targetPacked, level, internalformat, width,
+                                             height, border, imageSize, dataSize, data))
+        {
+            context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height,
+                                                border, imageSize, dataSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage2DRobustANGLE(GLenum target,
+                                                    GLint level,
+                                                    GLsizei xoffset,
+                                                    GLsizei yoffset,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLenum format,
+                                                    GLsizei imageSize,
+                                                    GLsizei dataSize,
+                                                    const GLvoid *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLsizei xoffset = %d, GLsizei yoffset = %d, "
+        "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLsizei imageSize = %d, "
+        "GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, width, height, format, imageSize, dataSize,
+        (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage2DRobustANGLE, context, targetPacked, level, xoffset,
+                      yoffset, width, height, format, imageSize, dataSize, data);
+        if (context->skipValidation() || ValidateCompressedTexSubImage2DRobustANGLE(
+                                             context, targetPacked, level, xoffset, yoffset, width,
+                                             height, format, imageSize, dataSize, data))
+        {
+            context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width,
+                                                   height, format, imageSize, dataSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexImage3DRobustANGLE(GLenum target,
+                                                 GLint level,
+                                                 GLenum internalformat,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLsizei depth,
+                                                 GLint border,
+                                                 GLsizei imageSize,
+                                                 GLsizei dataSize,
+                                                 const GLvoid *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, "
+        "GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, imageSize, dataSize,
+        (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage3DRobustANGLE, context, targetPacked, level, internalformat,
+                      width, height, depth, border, imageSize, dataSize, data);
+        if (context->skipValidation() || ValidateCompressedTexImage3DRobustANGLE(
+                                             context, targetPacked, level, internalformat, width,
+                                             height, depth, border, imageSize, dataSize, data))
+        {
+            context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height,
+                                                depth, border, imageSize, dataSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage3DRobustANGLE(GLenum target,
+                                                    GLint level,
+                                                    GLint xoffset,
+                                                    GLint yoffset,
+                                                    GLint zoffset,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLsizei depth,
+                                                    GLenum format,
+                                                    GLsizei imageSize,
+                                                    GLsizei dataSize,
+                                                    const GLvoid *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLsizei imageSize = %d, GLsizei dataSize = %d, const GLvoid * data = "
+        "0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, dataSize,
+        (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage3DRobustANGLE, context, targetPacked, level, xoffset,
+                      yoffset, zoffset, width, height, depth, format, imageSize, dataSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexSubImage3DRobustANGLE(context, targetPacked, level, xoffset,
+                                                       yoffset, zoffset, width, height, depth,
+                                                       format, imageSize, dataSize, data))
+        {
+            context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset,
+                                                   width, height, depth, format, imageSize,
+                                                   dataSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY
+GetQueryivRobustANGLE(GLenum target, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(GetQueryivRobustANGLE, context, targetPacked, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryivRobustANGLE(context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getQueryivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectuivRobustANGLE(GLuint id,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLuint *params)
+{
+    EVENT(
+        "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        id, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjectuivRobustANGLE, context, id, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryObjectuivRobustANGLE(context, id, pname, bufSize, length, params))
+        {
+            context->getQueryObjectuivRobust(id, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferPointervRobustANGLE(GLenum target,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              void **params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", void ** params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferPointervRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetBufferPointervRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY
+GetIntegeri_vRobustANGLE(GLenum target, GLuint index, GLsizei bufSize, GLsizei *length, GLint *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * data = 0x%016" PRIxPTR ")",
+        target, index, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetIntegeri_vRobustANGLE, context, target, index, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetIntegeri_vRobustANGLE(context, target, index, bufSize, length, data))
+        {
+            context->getIntegeri_vRobust(target, index, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetInternalformativRobustANGLE(GLenum target,
+                                                GLenum internalformat,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLenum pname = 0x%X, GLsizei bufSize "
+        "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, internalformat, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetInternalformativRobustANGLE, context, target, internalformat, pname,
+                      bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetInternalformativRobustANGLE(context, target, internalformat, pname, bufSize,
+                                                   length, params))
+        {
+            context->getInternalformativRobust(target, internalformat, pname, bufSize, length,
+                                               params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribIivRobustANGLE(GLuint index,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *params)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribIivRobustANGLE, context, index, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribIivRobustANGLE(context, index, pname, bufSize, length, params))
+        {
+            context->getVertexAttribIivRobust(index, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribIuivRobustANGLE(GLuint index,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLuint *params)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetVertexAttribIuivRobustANGLE, context, index, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribIuivRobustANGLE(context, index, pname, bufSize, length, params))
+        {
+            context->getVertexAttribIuivRobust(index, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformuivRobustANGLE(GLuint program,
+                                          GLint location,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLuint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUniformuivRobustANGLE, context, program, location, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetUniformuivRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getUniformuivRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformBlockivRobustANGLE(GLuint program,
+                                                    GLuint uniformBlockIndex,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = 0x%X, GLsizei bufSize "
+        "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, uniformBlockIndex, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetActiveUniformBlockivRobustANGLE, context, program, uniformBlockIndex,
+                      pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetActiveUniformBlockivRobustANGLE(context, program, uniformBlockIndex, pname,
+                                                       bufSize, length, params))
+        {
+            context->getActiveUniformBlockivRobust(program, uniformBlockIndex, pname, bufSize,
+                                                   length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetInteger64vRobustANGLE(GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint64 *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", GLint64 * data = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetInteger64vRobustANGLE, context, pname, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetInteger64vRobustANGLE(context, pname, bufSize, length, data))
+        {
+            context->getInteger64vRobust(pname, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetInteger64i_vRobustANGLE(GLenum target,
+                                            GLuint index,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint64 *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint64 * data = 0x%016" PRIxPTR ")",
+        target, index, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetInteger64i_vRobustANGLE, context, target, index, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetInteger64i_vRobustANGLE(context, target, index, bufSize, length, data))
+        {
+            context->getInteger64i_vRobust(target, index, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferParameteri64vRobustANGLE(GLenum target,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint64 *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferParameteri64vRobustANGLE, context, targetPacked, pname, bufSize,
+                      length, params);
+        if (context->skipValidation() || ValidateGetBufferParameteri64vRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterivRobustANGLE(GLuint sampler,
+                                               GLuint pname,
+                                               GLsizei bufSize,
+                                               const GLint *param)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLuint pname = %u, GLsizei bufSize = %d, const GLint * param = "
+        "0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameterivRobustANGLE, context, sampler, pname, bufSize, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterivRobustANGLE(context, sampler, pname, bufSize, param))
+        {
+            context->samplerParameterivRobust(sampler, pname, bufSize, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterfvRobustANGLE(GLuint sampler,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               const GLfloat *param)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLfloat * param = "
+        "0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameterfvRobustANGLE, context, sampler, pname, bufSize, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterfvRobustANGLE(context, sampler, pname, bufSize, param))
+        {
+            context->samplerParameterfvRobust(sampler, pname, bufSize, param);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterivRobustANGLE(GLuint sampler,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLint *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSamplerParameterivRobustANGLE, context, sampler, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetSamplerParameterivRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getSamplerParameterivRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterfvRobustANGLE(GLuint sampler,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLfloat *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSamplerParameterfvRobustANGLE, context, sampler, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetSamplerParameterfvRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getSamplerParameterfvRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferParameterivRobustANGLE(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFramebufferParameterivRobustANGLE, context, sampler, pname, bufSize,
+                      length, params);
+        if (context->skipValidation() || ValidateGetFramebufferParameterivRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getFramebufferParameterivRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramInterfaceivRobustANGLE(GLuint program,
+                                                  GLenum programInterface,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, GLenum pname = 0x%X, GLsizei "
+        "bufSize = %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, programInterface, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramInterfaceivRobustANGLE, context, program, programInterface, pname,
+                      bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramInterfaceivRobustANGLE(context, program, programInterface, pname,
+                                                     bufSize, length, params))
+        {
+            context->getProgramInterfaceivRobust(program, programInterface, pname, bufSize, length,
+                                                 params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBooleani_vRobustANGLE(GLenum target,
+                                          GLuint index,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLboolean *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLboolean * data = 0x%016" PRIxPTR ")",
+        target, index, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetBooleani_vRobustANGLE, context, target, index, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetBooleani_vRobustANGLE(context, target, index, bufSize, length, data))
+        {
+            context->getBooleani_vRobust(target, index, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetMultisamplefvRobustANGLE(GLenum pname,
+                                             GLuint index,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLfloat *val)
+{
+    EVENT(
+        "(GLenum pname = 0x%X, GLuint index = %u, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * val = 0x%016" PRIxPTR ")",
+        pname, index, bufSize, (uintptr_t)length, (uintptr_t)val);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetMultisamplefvRobustANGLE, context, pname, index, bufSize, length, val);
+        if (context->skipValidation() ||
+            ValidateGetMultisamplefvRobustANGLE(context, pname, index, bufSize, length, val))
+        {
+            context->getMultisamplefvRobust(pname, index, bufSize, length, val);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterivRobustANGLE(GLenum target,
+                                                   GLint level,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLsizei bufSize = %d, "
+        "GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, level, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterivRobustANGLE, context, targetPacked, level, pname,
+                      bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterivRobustANGLE(context, targetPacked, level, pname, bufSize,
+                                                      length, params))
+        {
+            context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length,
+                                                  params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterfvRobustANGLE(GLenum target,
+                                                   GLint level,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLsizei bufSize = %d, "
+        "GLsizei * length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        target, level, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterfvRobustANGLE, context, targetPacked, level, pname,
+                      bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterfvRobustANGLE(context, targetPacked, level, pname, bufSize,
+                                                      length, params))
+        {
+            context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length,
+                                                  params);
+        }
+    }
+}
+
+void GL_APIENTRY GetPointervRobustANGLERobustANGLE(GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   void **params)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", void ** params = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetPointervRobustANGLERobustANGLE, context, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetPointervRobustANGLERobustANGLE(context, pname, bufSize, length, params))
+        {
+            context->getPointervRobustANGLERobust(pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY ReadnPixelsRobustANGLE(GLint x,
+                                        GLint y,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLenum format,
+                                        GLenum type,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLsizei *columns,
+                                        GLsizei *rows,
+                                        void *data)
+{
+    EVENT(
+        "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = "
+        "0x%X, GLenum type = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+        ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR
+        ", void * data = 0x%016" PRIxPTR ")",
+        x, y, width, height, format, type, bufSize, (uintptr_t)length, (uintptr_t)columns,
+        (uintptr_t)rows, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ReadnPixelsRobustANGLE, context, x, y, width, height, format, type, bufSize,
+                      length, columns, rows, data);
+        if (context->skipValidation() ||
+            ValidateReadnPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
+                                           length, columns, rows, data))
+        {
+            context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
+                                       rows, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformfvRobustANGLE(GLuint program,
+                                          GLint location,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLfloat *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetnUniformfvRobustANGLE, context, program, location, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformfvRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getnUniformfvRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformivRobustANGLE(GLuint program,
+                                          GLint location,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetnUniformivRobustANGLE, context, program, location, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformivRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getnUniformivRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformuivRobustANGLE(GLuint program,
+                                           GLint location,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLuint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetnUniformuivRobustANGLE, context, program, location, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformuivRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getnUniformuivRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterIivRobustANGLE(GLenum target,
+                                            GLenum pname,
+                                            GLsizei bufSize,
+                                            const GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLint * params = "
+        "0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterIivRobustANGLE, context, targetPacked, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterIivRobustANGLE(context, targetPacked, pname, bufSize, params))
+        {
+            context->texParameterIivRobust(targetPacked, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterIuivRobustANGLE(GLenum target,
+                                             GLenum pname,
+                                             GLsizei bufSize,
+                                             const GLuint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLuint * params = "
+        "0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterIuivRobustANGLE, context, targetPacked, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterIuivRobustANGLE(context, targetPacked, pname, bufSize, params))
+        {
+            context->texParameterIuivRobust(targetPacked, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterIivRobustANGLE(GLenum target,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterIivRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetTexParameterIivRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterIuivRobustANGLE(GLenum target,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLuint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterIuivRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetTexParameterIuivRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterIivRobustANGLE(GLuint sampler,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                const GLint *param)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLint * param = "
+        "0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameterIivRobustANGLE, context, sampler, pname, bufSize, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterIivRobustANGLE(context, sampler, pname, bufSize, param))
+        {
+            context->samplerParameterIivRobust(sampler, pname, bufSize, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterIuivRobustANGLE(GLuint sampler,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 const GLuint *param)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLuint * param = "
+        "0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameterIuivRobustANGLE, context, sampler, pname, bufSize, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterIuivRobustANGLE(context, sampler, pname, bufSize, param))
+        {
+            context->samplerParameterIuivRobust(sampler, pname, bufSize, param);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterIivRobustANGLE(GLuint sampler,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSamplerParameterIivRobustANGLE, context, sampler, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetSamplerParameterIivRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getSamplerParameterIivRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterIuivRobustANGLE(GLuint sampler,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLuint *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSamplerParameterIuivRobustANGLE, context, sampler, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetSamplerParameterIuivRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getSamplerParameterIuivRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectivRobustANGLE(GLuint id,
+                                             GLenum pname,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLint *params)
+{
+    EVENT(
+        "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        id, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjectivRobustANGLE, context, id, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryObjectivRobustANGLE(context, id, pname, bufSize, length, params))
+        {
+            context->getQueryObjectivRobust(id, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjecti64vRobustANGLE(GLuint id,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint64 *params)
+{
+    EVENT(
+        "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR ")",
+        id, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjecti64vRobustANGLE, context, id, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryObjecti64vRobustANGLE(context, id, pname, bufSize, length, params))
+        {
+            context->getQueryObjecti64vRobust(id, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectui64vRobustANGLE(GLuint id,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLuint64 *params)
+{
+    EVENT(
+        "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint64 * params = 0x%016" PRIxPTR ")",
+        id, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjectui64vRobustANGLE, context, id, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryObjectui64vRobustANGLE(context, id, pname, bufSize, length, params))
+        {
+            context->getQueryObjectui64vRobust(id, pname, bufSize, length, params);
+        }
+    }
+}
+
+// GL_ANGLE_texture_external_update
+void GL_APIENTRY TexImage2DExternalANGLE(GLenum target,
+                                         GLint level,
+                                         GLint internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X)",
+        target, level, internalformat, width, height, border, format, type);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage2DExternalANGLE, context, targetPacked, level, internalformat, width,
+                      height, border, format, type);
+        if (context->skipValidation() ||
+            ValidateTexImage2DExternalANGLE(context, targetPacked, level, internalformat, width,
+                                            height, border, format, type))
+        {
+            context->texImage2DExternal(targetPacked, level, internalformat, width, height, border,
+                                        format, type);
+        }
+    }
+}
+
+void GL_APIENTRY InvalidateTextureANGLE(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(InvalidateTextureANGLE, context, targetPacked);
+        if (context->skipValidation() || ValidateInvalidateTextureANGLE(context, targetPacked))
+        {
+            context->invalidateTexture(targetPacked);
+        }
+    }
+}
+
+// GL_ANGLE_texture_multisample
+void GL_APIENTRY TexStorage2DMultisampleANGLE(GLenum target,
+                                              GLsizei samples,
+                                              GLenum internalformat,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLboolean fixedsamplelocations)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLboolean fixedsamplelocations = %u)",
+        target, samples, internalformat, width, height, fixedsamplelocations);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage2DMultisampleANGLE, context, targetPacked, samples, internalformat,
+                      width, height, fixedsamplelocations);
+        if (context->skipValidation() ||
+            ValidateTexStorage2DMultisampleANGLE(context, targetPacked, samples, internalformat,
+                                                 width, height, fixedsamplelocations))
+        {
+            context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
+                                             fixedsamplelocations);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterivANGLE(GLenum target,
+                                             GLint level,
+                                             GLenum pname,
+                                             GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLint * params = "
+        "0x%016" PRIxPTR ")",
+        target, level, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterivANGLE, context, targetPacked, level, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterivANGLE(context, targetPacked, level, pname, params))
+        {
+            context->getTexLevelParameteriv(targetPacked, level, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterfvANGLE(GLenum target,
+                                             GLint level,
+                                             GLenum pname,
+                                             GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLfloat * params = "
+        "0x%016" PRIxPTR ")",
+        target, level, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterfvANGLE, context, targetPacked, level, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterfvANGLE(context, targetPacked, level, pname, params))
+        {
+            context->getTexLevelParameterfv(targetPacked, level, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val)
+{
+    EVENT("(GLenum pname = 0x%X, GLuint index = %u, GLfloat * val = 0x%016" PRIxPTR ")", pname,
+          index, (uintptr_t)val);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetMultisamplefvANGLE, context, pname, index, val);
+        if (context->skipValidation() || ValidateGetMultisamplefvANGLE(context, pname, index, val))
+        {
+            context->getMultisamplefv(pname, index, val);
+        }
+    }
+}
+
+void GL_APIENTRY SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask)
+{
+    EVENT("(GLuint maskNumber = %u, GLbitfield mask = 0x%X)", maskNumber, mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SampleMaskiANGLE, context, maskNumber, mask);
+        if (context->skipValidation() || ValidateSampleMaskiANGLE(context, maskNumber, mask))
+        {
+            context->sampleMaski(maskNumber, mask);
+        }
+    }
+}
+
+// GL_ANGLE_translated_shader_source
+void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader,
+                                                GLsizei bufsize,
+                                                GLsizei *length,
+                                                GLchar *source)
+{
+    EVENT("(GLuint shader = %u, GLsizei bufsize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *source = 0x%016" PRIxPTR ")",
+          shader, bufsize, (uintptr_t)length, (uintptr_t)source);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetTranslatedShaderSourceANGLE, context, shader, bufsize, length, source);
+        if (context->skipValidation() ||
+            ValidateGetTranslatedShaderSourceANGLE(context, shader, bufsize, length, source))
+        {
+            context->getTranslatedShaderSource(shader, bufsize, length, source);
+        }
+    }
+}
+
+// GL_CHROMIUM_bind_uniform_location
+void GL_APIENTRY BindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, const GLchar* name = 0x%016" PRIxPTR ")",
+          program, location, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindUniformLocationCHROMIUM, context, program, location, name);
+        if (context->skipValidation() ||
+            ValidateBindUniformLocationCHROMIUM(context, program, location, name))
+        {
+            context->bindUniformLocation(program, location, name);
+        }
+    }
+}
+
+// GL_CHROMIUM_copy_compressed_texture
+void GL_APIENTRY CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
+{
+    EVENT("(GLuint sourceId = %u, GLuint destId = %u)", sourceId, destId);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CompressedCopyTextureCHROMIUM, context, sourceId, destId);
+        if (context->skipValidation() ||
+            ValidateCompressedCopyTextureCHROMIUM(context, sourceId, destId))
+        {
+            context->compressedCopyTexture(sourceId, destId);
+        }
+    }
+}
+
+// GL_CHROMIUM_copy_texture
+void GL_APIENTRY CopyTextureCHROMIUM(GLuint sourceId,
+                                     GLint sourceLevel,
+                                     GLenum destTarget,
+                                     GLuint destId,
+                                     GLint destLevel,
+                                     GLint internalFormat,
+                                     GLenum destType,
+                                     GLboolean unpackFlipY,
+                                     GLboolean unpackPremultiplyAlpha,
+                                     GLboolean unpackUnmultiplyAlpha)
+{
+    EVENT(
+        "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
+        "%u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = 0x%X, GLboolean "
+        "unpackFlipY = %u, GLboolean unpackPremultiplyAlpha = %u, GLboolean unpackUnmultiplyAlpha "
+        "= %u)",
+        sourceId, sourceLevel, destTarget, destId, destLevel, internalFormat, destType, unpackFlipY,
+        unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget destTargetPacked = FromGLenum<TextureTarget>(destTarget);
+        ANGLE_CAPTURE(CopyTextureCHROMIUM, context, sourceId, sourceLevel, destTargetPacked, destId,
+                      destLevel, internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                      unpackUnmultiplyAlpha);
+        if (context->skipValidation() ||
+            ValidateCopyTextureCHROMIUM(context, sourceId, sourceLevel, destTargetPacked, destId,
+                                        destLevel, internalFormat, destType, unpackFlipY,
+                                        unpackPremultiplyAlpha, unpackUnmultiplyAlpha))
+        {
+            context->copyTexture(sourceId, sourceLevel, destTargetPacked, destId, destLevel,
+                                 internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                                 unpackUnmultiplyAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY CopySubTextureCHROMIUM(GLuint sourceId,
+                                        GLint sourceLevel,
+                                        GLenum destTarget,
+                                        GLuint destId,
+                                        GLint destLevel,
+                                        GLint xoffset,
+                                        GLint yoffset,
+                                        GLint x,
+                                        GLint y,
+                                        GLint width,
+                                        GLint height,
+                                        GLboolean unpackFlipY,
+                                        GLboolean unpackPremultiplyAlpha,
+                                        GLboolean unpackUnmultiplyAlpha)
+{
+    EVENT(
+        "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
+        "%u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint x = %d, GLint y = "
+        "%d, GLint width = %d, GLint height = %d, GLboolean unpackFlipY = %u, GLboolean "
+        "unpackPremultiplyAlpha = %u, GLboolean unpackUnmultiplyAlpha = %u)",
+        sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, x, y, width, height,
+        unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget destTargetPacked = FromGLenum<TextureTarget>(destTarget);
+        ANGLE_CAPTURE(CopySubTextureCHROMIUM, context, sourceId, sourceLevel, destTargetPacked,
+                      destId, destLevel, xoffset, yoffset, x, y, width, height, unpackFlipY,
+                      unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+        if (context->skipValidation() ||
+            ValidateCopySubTextureCHROMIUM(context, sourceId, sourceLevel, destTargetPacked, destId,
+                                           destLevel, xoffset, yoffset, x, y, width, height,
+                                           unpackFlipY, unpackPremultiplyAlpha,
+                                           unpackUnmultiplyAlpha))
+        {
+            context->copySubTexture(sourceId, sourceLevel, destTargetPacked, destId, destLevel,
+                                    xoffset, yoffset, x, y, width, height, unpackFlipY,
+                                    unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+        }
+    }
+}
+
+// GL_CHROMIUM_framebuffer_mixed_samples
+void GL_APIENTRY CoverageModulationCHROMIUM(GLenum components)
+{
+    EVENT("(GLenum components = 0x%X)", components);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CoverageModulationCHROMIUM, context, components);
+        if (context->skipValidation() || ValidateCoverageModulationCHROMIUM(context, components))
+        {
+            context->coverageModulation(components);
+        }
+    }
+}
+
+void GL_APIENTRY MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat *matrix)
+{
+    EVENT("(GLenum matrixMode = 0x%X, const GLfloat * matrix = 0x%016" PRIxPTR ")", matrixMode,
+          (uintptr_t)matrix);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MatrixLoadfCHROMIUM, context, matrixMode, matrix);
+        if (context->skipValidation() || ValidateMatrixLoadfCHROMIUM(context, matrixMode, matrix))
+        {
+            context->matrixLoadf(matrixMode, matrix);
+        }
+    }
+}
+
+void GL_APIENTRY MatrixLoadIdentityCHROMIUM(GLenum matrixMode)
+{
+    EVENT("(GLenum matrixMode = 0x%X)", matrixMode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MatrixLoadIdentityCHROMIUM, context, matrixMode);
+        if (context->skipValidation() || ValidateMatrixLoadIdentityCHROMIUM(context, matrixMode))
+        {
+            context->matrixLoadIdentity(matrixMode);
+        }
+    }
+}
+
+// GL_CHROMIUM_lose_context
+void GL_APIENTRY LoseContextCHROMIUM(GLenum current, GLenum other)
+{
+    EVENT("(GLenum current = 0x%X, GLenum other = 0x%X)", current, other);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        GraphicsResetStatus currentPacked = FromGLenum<GraphicsResetStatus>(current);
+        GraphicsResetStatus otherPacked   = FromGLenum<GraphicsResetStatus>(other);
+        ANGLE_CAPTURE(LoseContextCHROMIUM, context, currentPacked, otherPacked);
+        if (context->skipValidation() ||
+            ValidateLoseContextCHROMIUM(context, currentPacked, otherPacked))
+        {
+            context->loseContext(currentPacked, otherPacked);
+        }
+    }
+}
+
+// GL_CHROMIUM_path_rendering
+GLuint GL_APIENTRY GenPathsCHROMIUM(GLsizei range)
+{
+    EVENT("(GLsizei range = %d)", range);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenPathsCHROMIUM, context, range);
+        if (context->skipValidation() || ValidateGenPathsCHROMIUM(context, range))
+        {
+            return context->genPaths(range);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GenPathsCHROMIUM, GLuint>();
+}
+
+void GL_APIENTRY DeletePathsCHROMIUM(GLuint first, GLsizei range)
+{
+    EVENT("(GLuint first = %u, GLsizei range = %d)", first, range);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeletePathsCHROMIUM, context, first, range);
+        if (context->skipValidation() || ValidateDeletePathsCHROMIUM(context, first, range))
+        {
+            context->deletePaths(first, range);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsPathCHROMIUM(GLuint path)
+{
+    EVENT("(GLuint path = %u)", path);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsPathCHROMIUM, context, path);
+        if (context->skipValidation() || ValidateIsPathCHROMIUM(context, path))
+        {
+            return context->isPath(path);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsPathCHROMIUM, GLboolean>();
+}
+
+void GL_APIENTRY PathCommandsCHROMIUM(GLuint path,
+                                      GLsizei numCommands,
+                                      const GLubyte *commands,
+                                      GLsizei numCoords,
+                                      GLenum coordType,
+                                      const void *coords)
+{
+    EVENT("(GLuint path = %u, GLsizei numCommands = %d, const GLubyte * commands = 0x%016" PRIxPTR
+          ", GLsizei numCoords = %d, GLenum coordType = 0x%X, const void* coords = 0x%016" PRIxPTR
+          ")",
+          path, numCommands, (uintptr_t)commands, numCoords, coordType, (uintptr_t)coords);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PathCommandsCHROMIUM, context, path, numCommands, commands, numCoords,
+                      coordType, coords);
+        if (context->skipValidation() ||
+            ValidatePathCommandsCHROMIUM(context, path, numCommands, commands, numCoords, coordType,
+                                         coords))
+        {
+            context->pathCommands(path, numCommands, commands, numCoords, coordType, coords);
+        }
+    }
+}
+
+void GL_APIENTRY PathParameterfCHROMIUM(GLuint path, GLenum pname, GLfloat value)
+{
+    EVENT("(GLuint path = %u, GLenum pname = 0x%X, GLfloat value = %f)", path, pname, value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PathParameterfCHROMIUM, context, path, pname, value);
+        if (context->skipValidation() ||
+            ValidatePathParameterfCHROMIUM(context, path, pname, value))
+        {
+            context->pathParameterf(path, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY PathParameteriCHROMIUM(GLuint path, GLenum pname, GLint value)
+{
+    EVENT("(GLuint path = %u, GLenum pname = 0x%X, GLint value = %d)", path, pname, value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PathParameteriCHROMIUM, context, path, pname, value);
+        if (context->skipValidation() ||
+            ValidatePathParameteriCHROMIUM(context, path, pname, value))
+        {
+            context->pathParameteri(path, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY GetPathParameterfvCHROMIUM(GLuint path, GLenum pname, GLfloat *value)
+{
+    EVENT("(GLuint path = %u, GLenum pname = 0x%X, GLfloat * value = 0x%016" PRIxPTR ")", path,
+          pname, (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetPathParameterfvCHROMIUM, context, path, pname, value);
+        if (context->skipValidation() ||
+            ValidateGetPathParameterfvCHROMIUM(context, path, pname, value))
+        {
+            context->getPathParameterfv(path, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY GetPathParameterivCHROMIUM(GLuint path, GLenum pname, GLint *value)
+{
+    EVENT("(GLuint path = %u, GLenum pname = 0x%X, GLint * value = 0x%016" PRIxPTR ")", path, pname,
+          (uintptr_t)value);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetPathParameterivCHROMIUM, context, path, pname, value);
+        if (context->skipValidation() ||
+            ValidateGetPathParameterivCHROMIUM(context, path, pname, value))
+        {
+            context->getPathParameteriv(path, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY PathStencilFuncCHROMIUM(GLenum func, GLint ref, GLuint mask)
+{
+    EVENT("(GLenum func = 0x%X, GLint ref = %d, GLuint mask = %u)", func, ref, mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PathStencilFuncCHROMIUM, context, func, ref, mask);
+        if (context->skipValidation() || ValidatePathStencilFuncCHROMIUM(context, func, ref, mask))
+        {
+            context->pathStencilFunc(func, ref, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilFillPathCHROMIUM(GLuint path, GLenum fillMode, GLuint mask)
+{
+    EVENT("(GLuint path = %u, GLenum fillMode = 0x%X, GLuint mask = %u)", path, fillMode, mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilFillPathCHROMIUM, context, path, fillMode, mask);
+        if (context->skipValidation() ||
+            ValidateStencilFillPathCHROMIUM(context, path, fillMode, mask))
+        {
+            context->stencilFillPath(path, fillMode, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilStrokePathCHROMIUM(GLuint path, GLint reference, GLuint mask)
+{
+    EVENT("(GLuint path = %u, GLint reference = %d, GLuint mask = %u)", path, reference, mask);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilStrokePathCHROMIUM, context, path, reference, mask);
+        if (context->skipValidation() ||
+            ValidateStencilStrokePathCHROMIUM(context, path, reference, mask))
+        {
+            context->stencilStrokePath(path, reference, mask);
+        }
+    }
+}
+
+void GL_APIENTRY CoverFillPathCHROMIUM(GLuint path, GLenum coverMode)
+{
+    EVENT("(GLuint path = %u, GLenum coverMode = 0x%X)", path, coverMode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CoverFillPathCHROMIUM, context, path, coverMode);
+        if (context->skipValidation() || ValidateCoverFillPathCHROMIUM(context, path, coverMode))
+        {
+            context->coverFillPath(path, coverMode);
+        }
+    }
+}
+
+void GL_APIENTRY CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode)
+{
+    EVENT("(GLuint path = %u, GLenum coverMode = 0x%X)", path, coverMode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CoverStrokePathCHROMIUM, context, path, coverMode);
+        if (context->skipValidation() || ValidateCoverStrokePathCHROMIUM(context, path, coverMode))
+        {
+            context->coverStrokePath(path, coverMode);
+        }
+    }
+}
+
+void GL_APIENTRY StencilThenCoverFillPathCHROMIUM(GLuint path,
+                                                  GLenum fillMode,
+                                                  GLuint mask,
+                                                  GLenum coverMode)
+{
+    EVENT("(GLuint path = %u, GLenum fillMode = 0x%X, GLuint mask = %u, GLenum coverMode = 0x%X)",
+          path, fillMode, mask, coverMode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilThenCoverFillPathCHROMIUM, context, path, fillMode, mask, coverMode);
+        if (context->skipValidation() ||
+            ValidateStencilThenCoverFillPathCHROMIUM(context, path, fillMode, mask, coverMode))
+        {
+            context->stencilThenCoverFillPath(path, fillMode, mask, coverMode);
+        }
+    }
+}
+
+void GL_APIENTRY StencilThenCoverStrokePathCHROMIUM(GLuint path,
+                                                    GLint reference,
+                                                    GLuint mask,
+                                                    GLenum coverMode)
+{
+    EVENT("(GLuint path = %u, GLint reference = %d, GLuint mask = %u, GLenum coverMode = 0x%X)",
+          path, reference, mask, coverMode);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilThenCoverStrokePathCHROMIUM, context, path, reference, mask,
+                      coverMode);
+        if (context->skipValidation() ||
+            ValidateStencilThenCoverStrokePathCHROMIUM(context, path, reference, mask, coverMode))
+        {
+            context->stencilThenCoverStrokePath(path, reference, mask, coverMode);
+        }
+    }
+}
+
+void GL_APIENTRY CoverFillPathInstancedCHROMIUM(GLsizei numPath,
+                                                GLenum pathNameType,
+                                                const void *paths,
+                                                GLuint pathBase,
+                                                GLenum coverMode,
+                                                GLenum transformType,
+                                                const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPath = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLenum coverMode = 0x%X, GLenum transformType = 0x%X, const "
+          "GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPath, pathNameType, (uintptr_t)paths, pathBase, coverMode, transformType,
+          (uintptr_t)transformValues);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CoverFillPathInstancedCHROMIUM, context, numPath, pathNameType, paths,
+                      pathBase, coverMode, transformType, transformValues);
+        if (context->skipValidation() ||
+            ValidateCoverFillPathInstancedCHROMIUM(context, numPath, pathNameType, paths, pathBase,
+                                                   coverMode, transformType, transformValues))
+        {
+            context->coverFillPathInstanced(numPath, pathNameType, paths, pathBase, coverMode,
+                                            transformType, transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY CoverStrokePathInstancedCHROMIUM(GLsizei numPath,
+                                                  GLenum pathNameType,
+                                                  const void *paths,
+                                                  GLuint pathBase,
+                                                  GLenum coverMode,
+                                                  GLenum transformType,
+                                                  const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPath = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLenum coverMode = 0x%X, GLenum transformType = 0x%X, const "
+          "GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPath, pathNameType, (uintptr_t)paths, pathBase, coverMode, transformType,
+          (uintptr_t)transformValues);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CoverStrokePathInstancedCHROMIUM, context, numPath, pathNameType, paths,
+                      pathBase, coverMode, transformType, transformValues);
+        if (context->skipValidation() || ValidateCoverStrokePathInstancedCHROMIUM(
+                                             context, numPath, pathNameType, paths, pathBase,
+                                             coverMode, transformType, transformValues))
+        {
+            context->coverStrokePathInstanced(numPath, pathNameType, paths, pathBase, coverMode,
+                                              transformType, transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY StencilStrokePathInstancedCHROMIUM(GLsizei numPath,
+                                                    GLenum pathNameType,
+                                                    const void *paths,
+                                                    GLuint pathBase,
+                                                    GLint reference,
+                                                    GLuint mask,
+                                                    GLenum transformType,
+                                                    const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPath = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLint reference = %d, GLuint mask = %u, GLenum transformType = "
+          "0x%X, const GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPath, pathNameType, (uintptr_t)paths, pathBase, reference, mask, transformType,
+          (uintptr_t)transformValues);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilStrokePathInstancedCHROMIUM, context, numPath, pathNameType, paths,
+                      pathBase, reference, mask, transformType, transformValues);
+        if (context->skipValidation() || ValidateStencilStrokePathInstancedCHROMIUM(
+                                             context, numPath, pathNameType, paths, pathBase,
+                                             reference, mask, transformType, transformValues))
+        {
+            context->stencilStrokePathInstanced(numPath, pathNameType, paths, pathBase, reference,
+                                                mask, transformType, transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY StencilFillPathInstancedCHROMIUM(GLsizei numPaths,
+                                                  GLenum pathNameType,
+                                                  const void *paths,
+                                                  GLuint pathBase,
+                                                  GLenum fillMode,
+                                                  GLuint mask,
+                                                  GLenum transformType,
+                                                  const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPaths = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLenum fillMode = 0x%X, GLuint mask = %u, GLenum transformType "
+          "= 0x%X, const GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPaths, pathNameType, (uintptr_t)paths, pathBase, fillMode, mask, transformType,
+          (uintptr_t)transformValues);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilFillPathInstancedCHROMIUM, context, numPaths, pathNameType, paths,
+                      pathBase, fillMode, mask, transformType, transformValues);
+        if (context->skipValidation() || ValidateStencilFillPathInstancedCHROMIUM(
+                                             context, numPaths, pathNameType, paths, pathBase,
+                                             fillMode, mask, transformType, transformValues))
+        {
+            context->stencilFillPathInstanced(numPaths, pathNameType, paths, pathBase, fillMode,
+                                              mask, transformType, transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY StencilThenCoverFillPathInstancedCHROMIUM(GLsizei numPaths,
+                                                           GLenum pathNameType,
+                                                           const void *paths,
+                                                           GLuint pathBase,
+                                                           GLenum fillMode,
+                                                           GLuint mask,
+                                                           GLenum coverMode,
+                                                           GLenum transformType,
+                                                           const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPaths = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLenum fillMode = 0x%X, GLuint mask = %u, GLenum coverMode = "
+          "0x%X, GLenum transformType = 0x%X, const GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPaths, pathNameType, (uintptr_t)paths, pathBase, fillMode, mask, coverMode,
+          transformType, (uintptr_t)transformValues);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilThenCoverFillPathInstancedCHROMIUM, context, numPaths, pathNameType,
+                      paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
+        if (context->skipValidation() ||
+            ValidateStencilThenCoverFillPathInstancedCHROMIUM(
+                context, numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+                transformType, transformValues))
+        {
+            context->stencilThenCoverFillPathInstanced(numPaths, pathNameType, paths, pathBase,
+                                                       fillMode, mask, coverMode, transformType,
+                                                       transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY StencilThenCoverStrokePathInstancedCHROMIUM(GLsizei numPaths,
+                                                             GLenum pathNameType,
+                                                             const void *paths,
+                                                             GLuint pathBase,
+                                                             GLint reference,
+                                                             GLuint mask,
+                                                             GLenum coverMode,
+                                                             GLenum transformType,
+                                                             const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPaths = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLint reference = %d, GLuint mask = %u, GLenum coverMode = "
+          "0x%X, GLenum transformType = 0x%X, const GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPaths, pathNameType, (uintptr_t)paths, pathBase, reference, mask, coverMode,
+          transformType, (uintptr_t)transformValues);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(StencilThenCoverStrokePathInstancedCHROMIUM, context, numPaths, pathNameType,
+                      paths, pathBase, reference, mask, coverMode, transformType, transformValues);
+        if (context->skipValidation() ||
+            ValidateStencilThenCoverStrokePathInstancedCHROMIUM(
+                context, numPaths, pathNameType, paths, pathBase, reference, mask, coverMode,
+                transformType, transformValues))
+        {
+            context->stencilThenCoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
+                                                         reference, mask, coverMode, transformType,
+                                                         transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY BindFragmentInputLocationCHROMIUM(GLuint programs,
+                                                   GLint location,
+                                                   const GLchar *name)
+{
+    EVENT("(GLuint programs = %u, GLint location = %d, const GLchar * name = 0x%016" PRIxPTR ")",
+          programs, location, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindFragmentInputLocationCHROMIUM, context, programs, location, name);
+        if (context->skipValidation() ||
+            ValidateBindFragmentInputLocationCHROMIUM(context, programs, location, name))
+        {
+            context->bindFragmentInputLocation(programs, location, name);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramPathFragmentInputGenCHROMIUM(GLuint program,
+                                                     GLint location,
+                                                     GLenum genMode,
+                                                     GLint components,
+                                                     const GLfloat *coeffs)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLenum genMode = 0x%X, GLint components = %d, "
+        "const GLfloat * coeffs = 0x%016" PRIxPTR ")",
+        program, location, genMode, components, (uintptr_t)coeffs);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramPathFragmentInputGenCHROMIUM, context, program, location, genMode,
+                      components, coeffs);
+        if (context->skipValidation() ||
+            ValidateProgramPathFragmentInputGenCHROMIUM(context, program, location, genMode,
+                                                        components, coeffs))
+        {
+            context->programPathFragmentInputGen(program, location, genMode, components, coeffs);
+        }
+    }
+}
+
+// GL_EXT_blend_func_extended
+void GL_APIENTRY BindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
+{
+    EVENT("(GLuint program = %u, GLuint color = %u, const GLchar *name = 0x%016" PRIxPTR ")",
+          program, color, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindFragDataLocationEXT, context, program, color, name);
+        if (context->skipValidation() ||
+            ValidateBindFragDataLocationEXT(context, program, color, name))
+        {
+            context->bindFragDataLocation(program, color, name);
+        }
+    }
+}
+
+void GL_APIENTRY BindFragDataLocationIndexedEXT(GLuint program,
+                                                GLuint colorNumber,
+                                                GLuint index,
+                                                const GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint colorNumber = %u, GLuint index = %u, const GLchar *name = "
+        "0x%016" PRIxPTR ")",
+        program, colorNumber, index, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindFragDataLocationIndexedEXT, context, program, colorNumber, index, name);
+        if (context->skipValidation() ||
+            ValidateBindFragDataLocationIndexedEXT(context, program, colorNumber, index, name))
+        {
+            context->bindFragDataLocationIndexed(program, colorNumber, index, name);
+        }
+    }
+}
+
+GLint GL_APIENTRY GetFragDataIndexEXT(GLuint program, const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFragDataIndexEXT, context, program, name);
+        if (context->skipValidation() || ValidateGetFragDataIndexEXT(context, program, name))
+        {
+            return context->getFragDataIndex(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetFragDataIndexEXT, GLint>();
+}
+
+GLint GL_APIENTRY GetProgramResourceLocationIndexEXT(GLuint program,
+                                                     GLenum programInterface,
+                                                     const GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, const GLchar *name = 0x%016" PRIxPTR
+        ")",
+        program, programInterface, (uintptr_t)name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramResourceLocationIndexEXT, context, program, programInterface, name);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceLocationIndexEXT(context, program, programInterface, name))
+        {
+            return context->getProgramResourceLocationIndex(program, programInterface, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetProgramResourceLocationIndexEXT, GLint>();
+}
+
+// GL_EXT_debug_marker
+void GL_APIENTRY InsertEventMarkerEXT(GLsizei length, const GLchar *marker)
+{
+    // Don't run an EVENT() macro on the EXT_debug_marker entry points.
+    // It can interfere with the debug events being set by the caller.
+    // EVENT("(GLsizei length = %d, const GLchar *marker = 0x%016" PRIxPTR ")", length,
+    // (uintptr_t)marker);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(InsertEventMarkerEXT, context, length, marker);
+        if (context->skipValidation() || ValidateInsertEventMarkerEXT(context, length, marker))
+        {
+            context->insertEventMarker(length, marker);
+        }
+    }
+}
+
+void GL_APIENTRY PopGroupMarkerEXT()
+{
+    // Don't run an EVENT() macro on the EXT_debug_marker entry points.
+    // It can interfere with the debug events being set by the caller.
+    // EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PopGroupMarkerEXT, context);
+        if (context->skipValidation() || ValidatePopGroupMarkerEXT(context))
+        {
+            context->popGroupMarker();
+        }
+    }
+}
+
+void GL_APIENTRY PushGroupMarkerEXT(GLsizei length, const GLchar *marker)
+{
+    // Don't run an EVENT() macro on the EXT_debug_marker entry points.
+    // It can interfere with the debug events being set by the caller.
+    // EVENT("(GLsizei length = %d, const GLchar *marker = 0x%016" PRIxPTR ")", length,
+    // (uintptr_t)marker);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PushGroupMarkerEXT, context, length, marker);
+        if (context->skipValidation() || ValidatePushGroupMarkerEXT(context, length, marker))
+        {
+            context->pushGroupMarker(length, marker);
+        }
+    }
+}
+
+// GL_EXT_discard_framebuffer
+void GL_APIENTRY DiscardFramebufferEXT(GLenum target,
+                                       GLsizei numAttachments,
+                                       const GLenum *attachments)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum *attachments = "
+        "0x%016" PRIxPTR ")",
+        target, numAttachments, (uintptr_t)attachments);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DiscardFramebufferEXT, context, target, numAttachments, attachments);
+        if (context->skipValidation() ||
+            ValidateDiscardFramebufferEXT(context, target, numAttachments, attachments))
+        {
+            context->discardFramebuffer(target, numAttachments, attachments);
+        }
+    }
+}
+
+// GL_EXT_disjoint_timer_query
+void GL_APIENTRY BeginQueryEXT(GLenum target, GLuint id)
+{
+    EVENT("(GLenum target = 0x%X, GLuint id = %u)", target, id);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(BeginQueryEXT, context, targetPacked, id);
+        if (context->skipValidation() || ValidateBeginQueryEXT(context, targetPacked, id))
+        {
+            context->beginQuery(targetPacked, id);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteQueriesEXT(GLsizei n, const GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteQueriesEXT, context, n, ids);
+        if (context->skipValidation() || ValidateDeleteQueriesEXT(context, n, ids))
+        {
+            context->deleteQueries(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY EndQueryEXT(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(EndQueryEXT, context, targetPacked);
+        if (context->skipValidation() || ValidateEndQueryEXT(context, targetPacked))
+        {
+            context->endQuery(targetPacked);
+        }
+    }
+}
+
+void GL_APIENTRY GenQueriesEXT(GLsizei n, GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenQueriesEXT, context, n, ids);
+        if (context->skipValidation() || ValidateGenQueriesEXT(context, n, ids))
+        {
+            context->genQueries(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLint64 *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjecti64vEXT, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjecti64vEXT(context, id, pname, params))
+        {
+            context->getQueryObjecti64v(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjectivEXT, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjectivEXT(context, id, pname, params))
+        {
+            context->getQueryObjectiv(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLuint64 *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjectui64vEXT, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjectui64vEXT(context, id, pname, params))
+        {
+            context->getQueryObjectui64v(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetQueryObjectuivEXT, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjectuivEXT(context, id, pname, params))
+        {
+            context->getQueryObjectuiv(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryivEXT(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(GetQueryivEXT, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryivEXT(context, targetPacked, pname, params))
+        {
+            context->getQueryiv(targetPacked, pname, params);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsQueryEXT(GLuint id)
+{
+    EVENT("(GLuint id = %u)", id);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsQueryEXT, context, id);
+        if (context->skipValidation() || ValidateIsQueryEXT(context, id))
+        {
+            return context->isQuery(id);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsQueryEXT, GLboolean>();
+}
+
+void GL_APIENTRY QueryCounterEXT(GLuint id, GLenum target)
+{
+    EVENT("(GLuint id = %u, GLenum target = 0x%X)", id, target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(QueryCounterEXT, context, id, targetPacked);
+        if (context->skipValidation() || ValidateQueryCounterEXT(context, id, targetPacked))
+        {
+            context->queryCounter(id, targetPacked);
+        }
+    }
+}
+
+// GL_EXT_draw_buffers
+void GL_APIENTRY DrawBuffersEXT(GLsizei n, const GLenum *bufs)
+{
+    EVENT("(GLsizei n = %d, const GLenum *bufs = 0x%016" PRIxPTR ")", n, (uintptr_t)bufs);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawBuffersEXT, context, n, bufs);
+        if (context->skipValidation() || ValidateDrawBuffersEXT(context, n, bufs))
+        {
+            context->drawBuffers(n, bufs);
+        }
+    }
+}
+
+// GL_EXT_geometry_shader
+void GL_APIENTRY FramebufferTextureEXT(GLenum target,
+                                       GLenum attachment,
+                                       GLuint texture,
+                                       GLint level)
+{
+    EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d)",
+          target, attachment, texture, level);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FramebufferTextureEXT, context, target, attachment, texture, level);
+        if (context->skipValidation() ||
+            ValidateFramebufferTextureEXT(context, target, attachment, texture, level))
+        {
+            context->framebufferTexture(target, attachment, texture, level);
+        }
+    }
+}
+
+// GL_EXT_instanced_arrays
+void GL_APIENTRY DrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount)
+{
+    EVENT("(GLenum mode = 0x%X, GLint start = %d, GLsizei count = %d, GLsizei primcount = %d)",
+          mode, start, count, primcount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArraysInstancedEXT, context, modePacked, start, count, primcount);
+        if (context->skipValidation() ||
+            ValidateDrawArraysInstancedEXT(context, modePacked, start, count, primcount))
+        {
+            context->drawArraysInstanced(modePacked, start, count, primcount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsInstancedEXT(GLenum mode,
+                                          GLsizei count,
+                                          GLenum type,
+                                          const void *indices,
+                                          GLsizei primcount)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = "
+        "0x%016" PRIxPTR ", GLsizei primcount = %d)",
+        mode, count, type, (uintptr_t)indices, primcount);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElementsInstancedEXT, context, modePacked, count, typePacked, indices,
+                      primcount);
+        if (context->skipValidation() ||
+            ValidateDrawElementsInstancedEXT(context, modePacked, count, typePacked, indices,
+                                             primcount))
+        {
+            context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribDivisorEXT(GLuint index, GLuint divisor)
+{
+    EVENT("(GLuint index = %u, GLuint divisor = %u)", index, divisor);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(VertexAttribDivisorEXT, context, index, divisor);
+        if (context->skipValidation() || ValidateVertexAttribDivisorEXT(context, index, divisor))
+        {
+            context->vertexAttribDivisor(index, divisor);
+        }
+    }
+}
+
+// GL_EXT_map_buffer_range
+void GL_APIENTRY FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length)
+{
+    EVENT("(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr length = %llu)", target,
+          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(FlushMappedBufferRangeEXT, context, targetPacked, offset, length);
+        if (context->skipValidation() ||
+            ValidateFlushMappedBufferRangeEXT(context, targetPacked, offset, length))
+        {
+            context->flushMappedBufferRange(targetPacked, offset, length);
+        }
+    }
+}
+
+void *GL_APIENTRY MapBufferRangeEXT(GLenum target,
+                                    GLintptr offset,
+                                    GLsizeiptr length,
+                                    GLbitfield access)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr length = %llu, GLbitfield "
+        "access = 0x%X)",
+        target, static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
+        access);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(MapBufferRangeEXT, context, targetPacked, offset, length, access);
+        if (context->skipValidation() ||
+            ValidateMapBufferRangeEXT(context, targetPacked, offset, length, access))
+        {
+            return context->mapBufferRange(targetPacked, offset, length, access);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::MapBufferRangeEXT, void *>();
+}
+
+// GL_EXT_memory_object
+void GL_APIENTRY BufferStorageMemEXT(GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizeiptr size = %llu, GLuint memory = %u, GLuint64 offset = "
+        "%llu)",
+        target, static_cast<unsigned long long>(size), memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(BufferStorageMemEXT, context, targetPacked, size, memory, offset);
+        if (context->skipValidation() ||
+            ValidateBufferStorageMemEXT(context, targetPacked, size, memory, offset))
+        {
+            context->bufferStorageMem(targetPacked, size, memory, offset);
+        }
+    }
+}
+
+void GL_APIENTRY CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
+{
+    EVENT("(GLsizei n = %d, GLuint *memoryObjects = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)memoryObjects);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CreateMemoryObjectsEXT, context, n, memoryObjects);
+        if (context->skipValidation() || ValidateCreateMemoryObjectsEXT(context, n, memoryObjects))
+        {
+            context->createMemoryObjects(n, memoryObjects);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects)
+{
+    EVENT("(GLsizei n = %d, const GLuint *memoryObjects = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)memoryObjects);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteMemoryObjectsEXT, context, n, memoryObjects);
+        if (context->skipValidation() || ValidateDeleteMemoryObjectsEXT(context, n, memoryObjects))
+        {
+            context->deleteMemoryObjects(n, memoryObjects);
+        }
+    }
+}
+
+void GL_APIENTRY GetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint memoryObject = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")",
+          memoryObject, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetMemoryObjectParameterivEXT, context, memoryObject, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetMemoryObjectParameterivEXT(context, memoryObject, pname, params))
+        {
+            context->getMemoryObjectParameteriv(memoryObject, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLubyte *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUnsignedBytevEXT, context, pname, data);
+        if (context->skipValidation() || ValidateGetUnsignedBytevEXT(context, pname, data))
+        {
+            context->getUnsignedBytev(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLubyte *data = 0x%016" PRIxPTR ")", target,
+          index, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetUnsignedBytei_vEXT, context, target, index, data);
+        if (context->skipValidation() ||
+            ValidateGetUnsignedBytei_vEXT(context, target, index, data))
+        {
+            context->getUnsignedBytei_v(target, index, data);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsMemoryObjectEXT(GLuint memoryObject)
+{
+    EVENT("(GLuint memoryObject = %u)", memoryObject);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsMemoryObjectEXT, context, memoryObject);
+        if (context->skipValidation() || ValidateIsMemoryObjectEXT(context, memoryObject))
+        {
+            return context->isMemoryObject(memoryObject);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsMemoryObjectEXT, GLboolean>();
+}
+
+void GL_APIENTRY MemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, const GLint *params)
+{
+    EVENT("(GLuint memoryObject = %u, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR
+          ")",
+          memoryObject, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MemoryObjectParameterivEXT, context, memoryObject, pname, params);
+        if (context->skipValidation() ||
+            ValidateMemoryObjectParameterivEXT(context, memoryObject, pname, params))
+        {
+            context->memoryObjectParameteriv(memoryObject, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorageMem2DEXT(GLenum target,
+                                    GLsizei levels,
+                                    GLenum internalFormat,
+                                    GLsizei width,
+                                    GLsizei height,
+                                    GLuint memory,
+                                    GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalFormat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLuint memory = %u, GLuint64 offset = %llu)",
+        target, levels, internalFormat, width, height, memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorageMem2DEXT, context, targetPacked, levels, internalFormat, width,
+                      height, memory, offset);
+        if (context->skipValidation() ||
+            ValidateTexStorageMem2DEXT(context, targetPacked, levels, internalFormat, width, height,
+                                       memory, offset))
+        {
+            context->texStorageMem2D(targetPacked, levels, internalFormat, width, height, memory,
+                                     offset);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorageMem2DMultisampleEXT(GLenum target,
+                                               GLsizei samples,
+                                               GLenum internalFormat,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLboolean fixedSampleLocations,
+                                               GLuint memory,
+                                               GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalFormat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLboolean fixedSampleLocations = %u, GLuint memory = %u, "
+        "GLuint64 offset = %llu)",
+        target, samples, internalFormat, width, height, fixedSampleLocations, memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorageMem2DMultisampleEXT, context, targetPacked, samples, internalFormat,
+                      width, height, fixedSampleLocations, memory, offset);
+        if (context->skipValidation() || ValidateTexStorageMem2DMultisampleEXT(
+                                             context, targetPacked, samples, internalFormat, width,
+                                             height, fixedSampleLocations, memory, offset))
+        {
+            context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width,
+                                                height, fixedSampleLocations, memory, offset);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorageMem3DEXT(GLenum target,
+                                    GLsizei levels,
+                                    GLenum internalFormat,
+                                    GLsizei width,
+                                    GLsizei height,
+                                    GLsizei depth,
+                                    GLuint memory,
+                                    GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalFormat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLuint memory = %u, GLuint64 offset = %llu)",
+        target, levels, internalFormat, width, height, depth, memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorageMem3DEXT, context, targetPacked, levels, internalFormat, width,
+                      height, depth, memory, offset);
+        if (context->skipValidation() ||
+            ValidateTexStorageMem3DEXT(context, targetPacked, levels, internalFormat, width, height,
+                                       depth, memory, offset))
+        {
+            context->texStorageMem3D(targetPacked, levels, internalFormat, width, height, depth,
+                                     memory, offset);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorageMem3DMultisampleEXT(GLenum target,
+                                               GLsizei samples,
+                                               GLenum internalFormat,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLsizei depth,
+                                               GLboolean fixedSampleLocations,
+                                               GLuint memory,
+                                               GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalFormat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLsizei depth = %d, GLboolean fixedSampleLocations = %u, "
+        "GLuint memory = %u, GLuint64 offset = %llu)",
+        target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorageMem3DMultisampleEXT, context, targetPacked, samples, internalFormat,
+                      width, height, depth, fixedSampleLocations, memory, offset);
+        if (context->skipValidation() || ValidateTexStorageMem3DMultisampleEXT(
+                                             context, targetPacked, samples, internalFormat, width,
+                                             height, depth, fixedSampleLocations, memory, offset))
+        {
+            context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width,
+                                                height, depth, fixedSampleLocations, memory,
+                                                offset);
+        }
+    }
+}
+
+// GL_EXT_memory_object_fd
+void GL_APIENTRY ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
+{
+    EVENT("(GLuint memory = %u, GLuint64 size = %llu, GLenum handleType = 0x%X, GLint fd = %d)",
+          memory, static_cast<unsigned long long>(size), handleType, fd);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        HandleType handleTypePacked = FromGLenum<HandleType>(handleType);
+        ANGLE_CAPTURE(ImportMemoryFdEXT, context, memory, size, handleTypePacked, fd);
+        if (context->skipValidation() ||
+            ValidateImportMemoryFdEXT(context, memory, size, handleTypePacked, fd))
+        {
+            context->importMemoryFd(memory, size, handleTypePacked, fd);
+        }
+    }
+}
+
+// GL_EXT_occlusion_query_boolean
+// BeginQueryEXT is already defined.
+
+// DeleteQueriesEXT is already defined.
+
+// EndQueryEXT is already defined.
+
+// GenQueriesEXT is already defined.
+
+// GetQueryObjectuivEXT is already defined.
+
+// GetQueryivEXT is already defined.
+
+// IsQueryEXT is already defined.
+
+// GL_EXT_robustness
+GLenum GL_APIENTRY GetGraphicsResetStatusEXT()
+{
+    EVENT("()");
+
+    Context *context = GetGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetGraphicsResetStatusEXT, context);
+        if (context->skipValidation() || ValidateGetGraphicsResetStatusEXT(context))
+        {
+            return context->getGraphicsResetStatus();
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatusEXT, GLenum>();
+}
+
+void GL_APIENTRY GetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLfloat *params = "
+        "0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetnUniformfvEXT, context, program, location, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformfvEXT(context, program, location, bufSize, params))
+        {
+            context->getnUniformfv(program, location, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetnUniformivEXT, context, program, location, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformivEXT(context, program, location, bufSize, params))
+        {
+            context->getnUniformiv(program, location, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY ReadnPixelsEXT(GLint x,
+                                GLint y,
+                                GLsizei width,
+                                GLsizei height,
+                                GLenum format,
+                                GLenum type,
+                                GLsizei bufSize,
+                                void *data)
+{
+    EVENT(
+        "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = "
+        "0x%X, GLenum type = 0x%X, GLsizei bufSize = %d, void *data = 0x%016" PRIxPTR ")",
+        x, y, width, height, format, type, bufSize, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ReadnPixelsEXT, context, x, y, width, height, format, type, bufSize, data);
+        if (context->skipValidation() ||
+            ValidateReadnPixelsEXT(context, x, y, width, height, format, type, bufSize, data))
+        {
+            context->readnPixels(x, y, width, height, format, type, bufSize, data);
+        }
+    }
+}
+
+// GL_EXT_semaphore
+void GL_APIENTRY DeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores)
+{
+    EVENT("(GLsizei n = %d, const GLuint *semaphores = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)semaphores);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteSemaphoresEXT, context, n, semaphores);
+        if (context->skipValidation() || ValidateDeleteSemaphoresEXT(context, n, semaphores))
+        {
+            context->deleteSemaphores(n, semaphores);
+        }
+    }
+}
+
+void GL_APIENTRY GenSemaphoresEXT(GLsizei n, GLuint *semaphores)
+{
+    EVENT("(GLsizei n = %d, GLuint *semaphores = 0x%016" PRIxPTR ")", n, (uintptr_t)semaphores);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenSemaphoresEXT, context, n, semaphores);
+        if (context->skipValidation() || ValidateGenSemaphoresEXT(context, n, semaphores))
+        {
+            context->genSemaphores(n, semaphores);
+        }
+    }
+}
+
+void GL_APIENTRY GetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params)
+{
+    EVENT("(GLuint semaphore = %u, GLenum pname = 0x%X, GLuint64 *params = 0x%016" PRIxPTR ")",
+          semaphore, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSemaphoreParameterui64vEXT, context, semaphore, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSemaphoreParameterui64vEXT(context, semaphore, pname, params))
+        {
+            context->getSemaphoreParameterui64v(semaphore, pname, params);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsSemaphoreEXT(GLuint semaphore)
+{
+    EVENT("(GLuint semaphore = %u)", semaphore);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsSemaphoreEXT, context, semaphore);
+        if (context->skipValidation() || ValidateIsSemaphoreEXT(context, semaphore))
+        {
+            return context->isSemaphore(semaphore);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsSemaphoreEXT, GLboolean>();
+}
+
+void GL_APIENTRY SemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, const GLuint64 *params)
+{
+    EVENT("(GLuint semaphore = %u, GLenum pname = 0x%X, const GLuint64 *params = 0x%016" PRIxPTR
+          ")",
+          semaphore, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SemaphoreParameterui64vEXT, context, semaphore, pname, params);
+        if (context->skipValidation() ||
+            ValidateSemaphoreParameterui64vEXT(context, semaphore, pname, params))
+        {
+            context->semaphoreParameterui64v(semaphore, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY SignalSemaphoreEXT(GLuint semaphore,
+                                    GLuint numBufferBarriers,
+                                    const GLuint *buffers,
+                                    GLuint numTextureBarriers,
+                                    const GLuint *textures,
+                                    const GLenum *dstLayouts)
+{
+    EVENT(
+        "(GLuint semaphore = %u, GLuint numBufferBarriers = %u, const GLuint *buffers = "
+        "0x%016" PRIxPTR ", GLuint numTextureBarriers = %u, const GLuint *textures = 0x%016" PRIxPTR
+        ", const GLenum *dstLayouts = 0x%016" PRIxPTR ")",
+        semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers, (uintptr_t)textures,
+        (uintptr_t)dstLayouts);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SignalSemaphoreEXT, context, semaphore, numBufferBarriers, buffers,
+                      numTextureBarriers, textures, dstLayouts);
+        if (context->skipValidation() ||
+            ValidateSignalSemaphoreEXT(context, semaphore, numBufferBarriers, buffers,
+                                       numTextureBarriers, textures, dstLayouts))
+        {
+            context->signalSemaphore(semaphore, numBufferBarriers, buffers, numTextureBarriers,
+                                     textures, dstLayouts);
+        }
+    }
+}
+
+void GL_APIENTRY WaitSemaphoreEXT(GLuint semaphore,
+                                  GLuint numBufferBarriers,
+                                  const GLuint *buffers,
+                                  GLuint numTextureBarriers,
+                                  const GLuint *textures,
+                                  const GLenum *srcLayouts)
+{
+    EVENT(
+        "(GLuint semaphore = %u, GLuint numBufferBarriers = %u, const GLuint *buffers = "
+        "0x%016" PRIxPTR ", GLuint numTextureBarriers = %u, const GLuint *textures = 0x%016" PRIxPTR
+        ", const GLenum *srcLayouts = 0x%016" PRIxPTR ")",
+        semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers, (uintptr_t)textures,
+        (uintptr_t)srcLayouts);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(WaitSemaphoreEXT, context, semaphore, numBufferBarriers, buffers,
+                      numTextureBarriers, textures, srcLayouts);
+        if (context->skipValidation() ||
+            ValidateWaitSemaphoreEXT(context, semaphore, numBufferBarriers, buffers,
+                                     numTextureBarriers, textures, srcLayouts))
+        {
+            context->waitSemaphore(semaphore, numBufferBarriers, buffers, numTextureBarriers,
+                                   textures, srcLayouts);
+        }
+    }
+}
+
+// GetUnsignedBytei_vEXT is already defined.
+
+// GetUnsignedBytevEXT is already defined.
+
+// GL_EXT_semaphore_fd
+void GL_APIENTRY ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
+{
+    EVENT("(GLuint semaphore = %u, GLenum handleType = 0x%X, GLint fd = %d)", semaphore, handleType,
+          fd);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        HandleType handleTypePacked = FromGLenum<HandleType>(handleType);
+        ANGLE_CAPTURE(ImportSemaphoreFdEXT, context, semaphore, handleTypePacked, fd);
+        if (context->skipValidation() ||
+            ValidateImportSemaphoreFdEXT(context, semaphore, handleTypePacked, fd))
+        {
+            context->importSemaphoreFd(semaphore, handleTypePacked, fd);
+        }
+    }
+}
+
+// GL_EXT_texture_storage
+void GL_APIENTRY TexStorage1DEXT(GLenum target,
+                                 GLsizei levels,
+                                 GLenum internalformat,
+                                 GLsizei width)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d)",
+        target, levels, internalformat, width);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TexStorage1DEXT, context, target, levels, internalformat, width);
+        if (context->skipValidation() ||
+            ValidateTexStorage1DEXT(context, target, levels, internalformat, width))
+        {
+            context->texStorage1D(target, levels, internalformat, width);
+        }
+    }
+}
+
+void GL_APIENTRY
+TexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d)",
+        target, levels, internalformat, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage2DEXT, context, targetPacked, levels, internalformat, width,
+                      height);
+        if (context->skipValidation() ||
+            ValidateTexStorage2DEXT(context, targetPacked, levels, internalformat, width, height))
+        {
+            context->texStorage2D(targetPacked, levels, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage3DEXT(GLenum target,
+                                 GLsizei levels,
+                                 GLenum internalformat,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLsizei depth)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d)",
+        target, levels, internalformat, width, height, depth);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage3DEXT, context, targetPacked, levels, internalformat, width, height,
+                      depth);
+        if (context->skipValidation() ||
+            ValidateTexStorage3DEXT(context, targetPacked, levels, internalformat, width, height,
+                                    depth))
+        {
+            context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
+        }
+    }
+}
+
+// GL_KHR_debug
+void GL_APIENTRY DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam)
+{
+    EVENT("(GLDEBUGPROCKHR callback = 0x%016" PRIxPTR ", const void *userParam = 0x%016" PRIxPTR
+          ")",
+          (uintptr_t)callback, (uintptr_t)userParam);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DebugMessageCallbackKHR, context, callback, userParam);
+        if (context->skipValidation() ||
+            ValidateDebugMessageCallbackKHR(context, callback, userParam))
+        {
+            context->debugMessageCallback(callback, userParam);
+        }
+    }
+}
+
+void GL_APIENTRY DebugMessageControlKHR(GLenum source,
+                                        GLenum type,
+                                        GLenum severity,
+                                        GLsizei count,
+                                        const GLuint *ids,
+                                        GLboolean enabled)
+{
+    EVENT(
+        "(GLenum source = 0x%X, GLenum type = 0x%X, GLenum severity = 0x%X, GLsizei count = %d, "
+        "const GLuint *ids = 0x%016" PRIxPTR ", GLboolean enabled = %u)",
+        source, type, severity, count, (uintptr_t)ids, enabled);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DebugMessageControlKHR, context, source, type, severity, count, ids, enabled);
+        if (context->skipValidation() ||
+            ValidateDebugMessageControlKHR(context, source, type, severity, count, ids, enabled))
+        {
+            context->debugMessageControl(source, type, severity, count, ids, enabled);
+        }
+    }
+}
+
+void GL_APIENTRY DebugMessageInsertKHR(GLenum source,
+                                       GLenum type,
+                                       GLuint id,
+                                       GLenum severity,
+                                       GLsizei length,
+                                       const GLchar *buf)
+{
+    EVENT(
+        "(GLenum source = 0x%X, GLenum type = 0x%X, GLuint id = %u, GLenum severity = 0x%X, "
+        "GLsizei length = %d, const GLchar *buf = 0x%016" PRIxPTR ")",
+        source, type, id, severity, length, (uintptr_t)buf);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DebugMessageInsertKHR, context, source, type, id, severity, length, buf);
+        if (context->skipValidation() ||
+            ValidateDebugMessageInsertKHR(context, source, type, id, severity, length, buf))
+        {
+            context->debugMessageInsert(source, type, id, severity, length, buf);
+        }
+    }
+}
+
+GLuint GL_APIENTRY GetDebugMessageLogKHR(GLuint count,
+                                         GLsizei bufSize,
+                                         GLenum *sources,
+                                         GLenum *types,
+                                         GLuint *ids,
+                                         GLenum *severities,
+                                         GLsizei *lengths,
+                                         GLchar *messageLog)
+{
+    EVENT("(GLuint count = %u, GLsizei bufSize = %d, GLenum *sources = 0x%016" PRIxPTR
+          ", GLenum *types = 0x%016" PRIxPTR ", GLuint *ids = 0x%016" PRIxPTR
+          ", GLenum *severities = 0x%016" PRIxPTR ", GLsizei *lengths = 0x%016" PRIxPTR
+          ", GLchar *messageLog = 0x%016" PRIxPTR ")",
+          count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
+          (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetDebugMessageLogKHR, context, count, bufSize, sources, types, ids,
+                      severities, lengths, messageLog);
+        if (context->skipValidation() ||
+            ValidateGetDebugMessageLogKHR(context, count, bufSize, sources, types, ids, severities,
+                                          lengths, messageLog))
+        {
+            return context->getDebugMessageLog(count, bufSize, sources, types, ids, severities,
+                                               lengths, messageLog);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetDebugMessageLogKHR, GLuint>();
+}
+
+void GL_APIENTRY
+GetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
+{
+    EVENT(
+        "(GLenum identifier = 0x%X, GLuint name = %u, GLsizei bufSize = %d, GLsizei *length = "
+        "0x%016" PRIxPTR ", GLchar *label = 0x%016" PRIxPTR ")",
+        identifier, name, bufSize, (uintptr_t)length, (uintptr_t)label);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetObjectLabelKHR, context, identifier, name, bufSize, length, label);
+        if (context->skipValidation() ||
+            ValidateGetObjectLabelKHR(context, identifier, name, bufSize, length, label))
+        {
+            context->getObjectLabel(identifier, name, bufSize, length, label);
+        }
+    }
+}
+
+void GL_APIENTRY GetObjectPtrLabelKHR(const void *ptr,
+                                      GLsizei bufSize,
+                                      GLsizei *length,
+                                      GLchar *label)
+{
+    EVENT("(const void *ptr = 0x%016" PRIxPTR
+          ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *label = 0x%016" PRIxPTR ")",
+          (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetObjectPtrLabelKHR, context, ptr, bufSize, length, label);
+        if (context->skipValidation() ||
+            ValidateGetObjectPtrLabelKHR(context, ptr, bufSize, length, label))
+        {
+            context->getObjectPtrLabel(ptr, bufSize, length, label);
+        }
+    }
+}
+
+void GL_APIENTRY GetPointervKHR(GLenum pname, void **params)
+{
+    EVENT("(GLenum pname = 0x%X, void **params = 0x%016" PRIxPTR ")", pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetPointervKHR, context, pname, params);
+        if (context->skipValidation() || ValidateGetPointervKHR(context, pname, params))
+        {
+            context->getPointerv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY ObjectLabelKHR(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
+{
+    EVENT(
+        "(GLenum identifier = 0x%X, GLuint name = %u, GLsizei length = %d, const GLchar *label = "
+        "0x%016" PRIxPTR ")",
+        identifier, name, length, (uintptr_t)label);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ObjectLabelKHR, context, identifier, name, length, label);
+        if (context->skipValidation() ||
+            ValidateObjectLabelKHR(context, identifier, name, length, label))
+        {
+            context->objectLabel(identifier, name, length, label);
+        }
+    }
+}
+
+void GL_APIENTRY ObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label)
+{
+    EVENT("(const void *ptr = 0x%016" PRIxPTR
+          ", GLsizei length = %d, const GLchar *label = 0x%016" PRIxPTR ")",
+          (uintptr_t)ptr, length, (uintptr_t)label);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ObjectPtrLabelKHR, context, ptr, length, label);
+        if (context->skipValidation() || ValidateObjectPtrLabelKHR(context, ptr, length, label))
+        {
+            context->objectPtrLabel(ptr, length, label);
+        }
+    }
+}
+
+void GL_APIENTRY PopDebugGroupKHR()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PopDebugGroupKHR, context);
+        if (context->skipValidation() || ValidatePopDebugGroupKHR(context))
+        {
+            context->popDebugGroup();
+        }
+    }
+}
+
+void GL_APIENTRY PushDebugGroupKHR(GLenum source, GLuint id, GLsizei length, const GLchar *message)
+{
+    EVENT(
+        "(GLenum source = 0x%X, GLuint id = %u, GLsizei length = %d, const GLchar *message = "
+        "0x%016" PRIxPTR ")",
+        source, id, length, (uintptr_t)message);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(PushDebugGroupKHR, context, source, id, length, message);
+        if (context->skipValidation() ||
+            ValidatePushDebugGroupKHR(context, source, id, length, message))
+        {
+            context->pushDebugGroup(source, id, length, message);
+        }
+    }
+}
+
+// GL_KHR_parallel_shader_compile
+void GL_APIENTRY MaxShaderCompilerThreadsKHR(GLuint count)
+{
+    EVENT("(GLuint count = %u)", count);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MaxShaderCompilerThreadsKHR, context, count);
+        if (context->skipValidation() || ValidateMaxShaderCompilerThreadsKHR(context, count))
+        {
+            context->maxShaderCompilerThreads(count);
+        }
+    }
+}
+
+// GL_NV_fence
+void GL_APIENTRY DeleteFencesNV(GLsizei n, const GLuint *fences)
+{
+    EVENT("(GLsizei n = %d, const GLuint *fences = 0x%016" PRIxPTR ")", n, (uintptr_t)fences);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteFencesNV, context, n, fences);
+        if (context->skipValidation() || ValidateDeleteFencesNV(context, n, fences))
+        {
+            context->deleteFencesNV(n, fences);
+        }
+    }
+}
+
+void GL_APIENTRY FinishFenceNV(GLuint fence)
+{
+    EVENT("(GLuint fence = %u)", fence);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FinishFenceNV, context, fence);
+        if (context->skipValidation() || ValidateFinishFenceNV(context, fence))
+        {
+            context->finishFenceNV(fence);
+        }
+    }
+}
+
+void GL_APIENTRY GenFencesNV(GLsizei n, GLuint *fences)
+{
+    EVENT("(GLsizei n = %d, GLuint *fences = 0x%016" PRIxPTR ")", n, (uintptr_t)fences);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenFencesNV, context, n, fences);
+        if (context->skipValidation() || ValidateGenFencesNV(context, n, fences))
+        {
+            context->genFencesNV(n, fences);
+        }
+    }
+}
+
+void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint fence = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", fence,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFenceivNV, context, fence, pname, params);
+        if (context->skipValidation() || ValidateGetFenceivNV(context, fence, pname, params))
+        {
+            context->getFenceivNV(fence, pname, params);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsFenceNV(GLuint fence)
+{
+    EVENT("(GLuint fence = %u)", fence);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsFenceNV, context, fence);
+        if (context->skipValidation() || ValidateIsFenceNV(context, fence))
+        {
+            return context->isFenceNV(fence);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsFenceNV, GLboolean>();
+}
+
+void GL_APIENTRY SetFenceNV(GLuint fence, GLenum condition)
+{
+    EVENT("(GLuint fence = %u, GLenum condition = 0x%X)", fence, condition);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SetFenceNV, context, fence, condition);
+        if (context->skipValidation() || ValidateSetFenceNV(context, fence, condition))
+        {
+            context->setFenceNV(fence, condition);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY TestFenceNV(GLuint fence)
+{
+    EVENT("(GLuint fence = %u)", fence);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TestFenceNV, context, fence);
+        if (context->skipValidation() || ValidateTestFenceNV(context, fence))
+        {
+            return context->testFenceNV(fence);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::TestFenceNV, GLboolean>();
+}
+
+// GL_OES_EGL_image
+void GL_APIENTRY EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
+{
+    EVENT("(GLenum target = 0x%X, GLeglImageOES image = 0x%016" PRIxPTR ")", target,
+          (uintptr_t)image);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(EGLImageTargetRenderbufferStorageOES, context, target, image);
+        if (context->skipValidation() ||
+            ValidateEGLImageTargetRenderbufferStorageOES(context, target, image))
+        {
+            context->eGLImageTargetRenderbufferStorage(target, image);
+        }
+    }
+}
+
+void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
+{
+    EVENT("(GLenum target = 0x%X, GLeglImageOES image = 0x%016" PRIxPTR ")", target,
+          (uintptr_t)image);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(EGLImageTargetTexture2DOES, context, targetPacked, image);
+        if (context->skipValidation() ||
+            ValidateEGLImageTargetTexture2DOES(context, targetPacked, image))
+        {
+            context->eGLImageTargetTexture2D(targetPacked, image);
+        }
+    }
+}
+
+// GL_OES_draw_texture
+void GL_APIENTRY DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
+{
+    EVENT(
+        "(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat width = %f, GLfloat height = %f)",
+        x, y, z, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawTexfOES, context, x, y, z, width, height);
+        if (context->skipValidation() || ValidateDrawTexfOES(context, x, y, z, width, height))
+        {
+            context->drawTexf(x, y, z, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexfvOES(const GLfloat *coords)
+{
+    EVENT("(const GLfloat *coords = 0x%016" PRIxPTR ")", (uintptr_t)coords);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawTexfvOES, context, coords);
+        if (context->skipValidation() || ValidateDrawTexfvOES(context, coords))
+        {
+            context->drawTexfv(coords);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
+{
+    EVENT("(GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height = %d)", x, y,
+          z, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawTexiOES, context, x, y, z, width, height);
+        if (context->skipValidation() || ValidateDrawTexiOES(context, x, y, z, width, height))
+        {
+            context->drawTexi(x, y, z, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexivOES(const GLint *coords)
+{
+    EVENT("(const GLint *coords = 0x%016" PRIxPTR ")", (uintptr_t)coords);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawTexivOES, context, coords);
+        if (context->skipValidation() || ValidateDrawTexivOES(context, coords))
+        {
+            context->drawTexiv(coords);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
+{
+    EVENT(
+        "(GLshort x = %d, GLshort y = %d, GLshort z = %d, GLshort width = %d, GLshort height = %d)",
+        x, y, z, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawTexsOES, context, x, y, z, width, height);
+        if (context->skipValidation() || ValidateDrawTexsOES(context, x, y, z, width, height))
+        {
+            context->drawTexs(x, y, z, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexsvOES(const GLshort *coords)
+{
+    EVENT("(const GLshort *coords = 0x%016" PRIxPTR ")", (uintptr_t)coords);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawTexsvOES, context, coords);
+        if (context->skipValidation() || ValidateDrawTexsvOES(context, coords))
+        {
+            context->drawTexsv(coords);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
+{
+    EVENT(
+        "(GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X, GLfixed width = 0x%X, GLfixed "
+        "height = 0x%X)",
+        x, y, z, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawTexxOES, context, x, y, z, width, height);
+        if (context->skipValidation() || ValidateDrawTexxOES(context, x, y, z, width, height))
+        {
+            context->drawTexx(x, y, z, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexxvOES(const GLfixed *coords)
+{
+    EVENT("(const GLfixed *coords = 0x%016" PRIxPTR ")", (uintptr_t)coords);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DrawTexxvOES, context, coords);
+        if (context->skipValidation() || ValidateDrawTexxvOES(context, coords))
+        {
+            context->drawTexxv(coords);
+        }
+    }
+}
+
+// GL_OES_framebuffer_object
+void GL_APIENTRY BindFramebufferOES(GLenum target, GLuint framebuffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint framebuffer = %u)", target, framebuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindFramebufferOES, context, target, framebuffer);
+        if (context->skipValidation() || ValidateBindFramebufferOES(context, target, framebuffer))
+        {
+            context->bindFramebuffer(target, framebuffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindRenderbufferOES(GLenum target, GLuint renderbuffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint renderbuffer = %u)", target, renderbuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindRenderbufferOES, context, target, renderbuffer);
+        if (context->skipValidation() || ValidateBindRenderbufferOES(context, target, renderbuffer))
+        {
+            context->bindRenderbuffer(target, renderbuffer);
+        }
+    }
+}
+
+GLenum GL_APIENTRY CheckFramebufferStatusOES(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CheckFramebufferStatusOES, context, target);
+        if (context->skipValidation() || ValidateCheckFramebufferStatusOES(context, target))
+        {
+            return context->checkFramebufferStatus(target);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CheckFramebufferStatusOES, GLenum>();
+}
+
+void GL_APIENTRY DeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *framebuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)framebuffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteFramebuffersOES, context, n, framebuffers);
+        if (context->skipValidation() || ValidateDeleteFramebuffersOES(context, n, framebuffers))
+        {
+            context->deleteFramebuffers(n, framebuffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *renderbuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)renderbuffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteRenderbuffersOES, context, n, renderbuffers);
+        if (context->skipValidation() || ValidateDeleteRenderbuffersOES(context, n, renderbuffers))
+        {
+            context->deleteRenderbuffers(n, renderbuffers);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferRenderbufferOES(GLenum target,
+                                            GLenum attachment,
+                                            GLenum renderbuffertarget,
+                                            GLuint renderbuffer)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, GLuint "
+        "renderbuffer = %u)",
+        target, attachment, renderbuffertarget, renderbuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FramebufferRenderbufferOES, context, target, attachment, renderbuffertarget,
+                      renderbuffer);
+        if (context->skipValidation() ||
+            ValidateFramebufferRenderbufferOES(context, target, attachment, renderbuffertarget,
+                                               renderbuffer))
+        {
+            context->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTexture2DOES(GLenum target,
+                                         GLenum attachment,
+                                         GLenum textarget,
+                                         GLuint texture,
+                                         GLint level)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, GLuint texture "
+        "= %u, GLint level = %d)",
+        target, attachment, textarget, texture, level);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget textargetPacked = FromGLenum<TextureTarget>(textarget);
+        ANGLE_CAPTURE(FramebufferTexture2DOES, context, target, attachment, textargetPacked,
+                      texture, level);
+        if (context->skipValidation() ||
+            ValidateFramebufferTexture2DOES(context, target, attachment, textargetPacked, texture,
+                                            level))
+        {
+            context->framebufferTexture2D(target, attachment, textargetPacked, texture, level);
+        }
+    }
+}
+
+void GL_APIENTRY GenFramebuffersOES(GLsizei n, GLuint *framebuffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *framebuffers = 0x%016" PRIxPTR ")", n, (uintptr_t)framebuffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenFramebuffersOES, context, n, framebuffers);
+        if (context->skipValidation() || ValidateGenFramebuffersOES(context, n, framebuffers))
+        {
+            context->genFramebuffers(n, framebuffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *renderbuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)renderbuffers);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenRenderbuffersOES, context, n, renderbuffers);
+        if (context->skipValidation() || ValidateGenRenderbuffersOES(context, n, renderbuffers))
+        {
+            context->genRenderbuffers(n, renderbuffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenerateMipmapOES(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GenerateMipmapOES, context, targetPacked);
+        if (context->skipValidation() || ValidateGenerateMipmapOES(context, targetPacked))
+        {
+            context->generateMipmap(targetPacked);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferAttachmentParameterivOES(GLenum target,
+                                                        GLenum attachment,
+                                                        GLenum pname,
+                                                        GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        target, attachment, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetFramebufferAttachmentParameterivOES, context, target, attachment, pname,
+                      params);
+        if (context->skipValidation() || ValidateGetFramebufferAttachmentParameterivOES(
+                                             context, target, attachment, pname, params))
+        {
+            context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetRenderbufferParameterivOES, context, target, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetRenderbufferParameterivOES(context, target, pname, params))
+        {
+            context->getRenderbufferParameteriv(target, pname, params);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsFramebufferOES(GLuint framebuffer)
+{
+    EVENT("(GLuint framebuffer = %u)", framebuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsFramebufferOES, context, framebuffer);
+        if (context->skipValidation() || ValidateIsFramebufferOES(context, framebuffer))
+        {
+            return context->isFramebuffer(framebuffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsFramebufferOES, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsRenderbufferOES(GLuint renderbuffer)
+{
+    EVENT("(GLuint renderbuffer = %u)", renderbuffer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsRenderbufferOES, context, renderbuffer);
+        if (context->skipValidation() || ValidateIsRenderbufferOES(context, renderbuffer))
+        {
+            return context->isRenderbuffer(renderbuffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsRenderbufferOES, GLboolean>();
+}
+
+void GL_APIENTRY RenderbufferStorageOES(GLenum target,
+                                        GLenum internalformat,
+                                        GLsizei width,
+                                        GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = "
+        "%d)",
+        target, internalformat, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(RenderbufferStorageOES, context, target, internalformat, width, height);
+        if (context->skipValidation() ||
+            ValidateRenderbufferStorageOES(context, target, internalformat, width, height))
+        {
+            context->renderbufferStorage(target, internalformat, width, height);
+        }
+    }
+}
+
+// GL_OES_get_program_binary
+void GL_APIENTRY GetProgramBinaryOES(GLuint program,
+                                     GLsizei bufSize,
+                                     GLsizei *length,
+                                     GLenum *binaryFormat,
+                                     void *binary)
+{
+    EVENT("(GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR ")",
+          program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat, (uintptr_t)binary);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetProgramBinaryOES, context, program, bufSize, length, binaryFormat, binary);
+        if (context->skipValidation() ||
+            ValidateGetProgramBinaryOES(context, program, bufSize, length, binaryFormat, binary))
+        {
+            context->getProgramBinary(program, bufSize, length, binaryFormat, binary);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramBinaryOES(GLuint program,
+                                  GLenum binaryFormat,
+                                  const void *binary,
+                                  GLint length)
+{
+    EVENT("(GLuint program = %u, GLenum binaryFormat = 0x%X, const void *binary = 0x%016" PRIxPTR
+          ", GLint length = %d)",
+          program, binaryFormat, (uintptr_t)binary, length);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(ProgramBinaryOES, context, program, binaryFormat, binary, length);
+        if (context->skipValidation() ||
+            ValidateProgramBinaryOES(context, program, binaryFormat, binary, length))
+        {
+            context->programBinary(program, binaryFormat, binary, length);
+        }
+    }
+}
+
+// GL_OES_mapbuffer
+void GL_APIENTRY GetBufferPointervOES(GLenum target, GLenum pname, void **params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, void **params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferPointervOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetBufferPointervOES(context, targetPacked, pname, params))
+        {
+            context->getBufferPointerv(targetPacked, pname, params);
+        }
+    }
+}
+
+void *GL_APIENTRY MapBufferOES(GLenum target, GLenum access)
+{
+    EVENT("(GLenum target = 0x%X, GLenum access = 0x%X)", target, access);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(MapBufferOES, context, targetPacked, access);
+        if (context->skipValidation() || ValidateMapBufferOES(context, targetPacked, access))
+        {
+            return context->mapBuffer(targetPacked, access);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::MapBufferOES, void *>();
+}
+
+GLboolean GL_APIENTRY UnmapBufferOES(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(UnmapBufferOES, context, targetPacked);
+        if (context->skipValidation() || ValidateUnmapBufferOES(context, targetPacked))
+        {
+            return context->unmapBuffer(targetPacked);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::UnmapBufferOES, GLboolean>();
+}
+
+// GL_OES_matrix_palette
+void GL_APIENTRY CurrentPaletteMatrixOES(GLuint matrixpaletteindex)
+{
+    EVENT("(GLuint matrixpaletteindex = %u)", matrixpaletteindex);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(CurrentPaletteMatrixOES, context, matrixpaletteindex);
+        if (context->skipValidation() ||
+            ValidateCurrentPaletteMatrixOES(context, matrixpaletteindex))
+        {
+            context->currentPaletteMatrix(matrixpaletteindex);
+        }
+    }
+}
+
+void GL_APIENTRY LoadPaletteFromModelViewMatrixOES()
+{
+    EVENT("()");
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(LoadPaletteFromModelViewMatrixOES, context);
+        if (context->skipValidation() || ValidateLoadPaletteFromModelViewMatrixOES(context))
+        {
+            context->loadPaletteFromModelViewMatrix();
+        }
+    }
+}
+
+void GL_APIENTRY MatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(MatrixIndexPointerOES, context, size, type, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateMatrixIndexPointerOES(context, size, type, stride, pointer))
+        {
+            context->matrixIndexPointer(size, type, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY WeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(WeightPointerOES, context, size, type, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateWeightPointerOES(context, size, type, stride, pointer))
+        {
+            context->weightPointer(size, type, stride, pointer);
+        }
+    }
+}
+
+// GL_OES_point_size_array
+void GL_APIENTRY PointSizePointerOES(GLenum type, GLsizei stride, const void *pointer)
+{
+    EVENT("(GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR ")",
+          type, stride, (uintptr_t)pointer);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(PointSizePointerOES, context, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidatePointSizePointerOES(context, typePacked, stride, pointer))
+        {
+            context->pointSizePointer(typePacked, stride, pointer);
+        }
+    }
+}
+
+// GL_OES_query_matrix
+GLbitfield GL_APIENTRY QueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
+{
+    EVENT("(GLfixed *mantissa = 0x%016" PRIxPTR ", GLint *exponent = 0x%016" PRIxPTR ")",
+          (uintptr_t)mantissa, (uintptr_t)exponent);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(QueryMatrixxOES, context, mantissa, exponent);
+        if (context->skipValidation() || ValidateQueryMatrixxOES(context, mantissa, exponent))
+        {
+            return context->queryMatrixx(mantissa, exponent);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::QueryMatrixxOES, GLbitfield>();
+}
+
+// GL_OES_texture_3D
+void GL_APIENTRY CompressedTexImage3DOES(GLenum target,
+                                         GLint level,
+                                         GLenum internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLint border,
+                                         GLsizei imageSize,
+                                         const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, "
+        "const void *data = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, imageSize, (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage3DOES, context, targetPacked, level, internalformat, width,
+                      height, depth, border, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexImage3DOES(context, targetPacked, level, internalformat, width,
+                                            height, depth, border, imageSize, data))
+        {
+            context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
+                                          border, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage3DOES(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLsizei imageSize,
+                                            const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize,
+        (uintptr_t)data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage3DOES, context, targetPacked, level, xoffset, yoffset,
+                      zoffset, width, height, depth, format, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset,
+                                               zoffset, width, height, depth, format, imageSize,
+                                               data))
+        {
+            context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
+                                             height, depth, format, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexSubImage3DOES(GLenum target,
+                                      GLint level,
+                                      GLint xoffset,
+                                      GLint yoffset,
+                                      GLint zoffset,
+                                      GLint x,
+                                      GLint y,
+                                      GLsizei width,
+                                      GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+        target, level, xoffset, yoffset, zoffset, x, y, width, height);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CopyTexSubImage3DOES, context, targetPacked, level, xoffset, yoffset, zoffset,
+                      x, y, width, height);
+        if (context->skipValidation() ||
+            ValidateCopyTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset, zoffset, x,
+                                         y, width, height))
+        {
+            context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
+                                       height);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTexture3DOES(GLenum target,
+                                         GLenum attachment,
+                                         GLenum textarget,
+                                         GLuint texture,
+                                         GLint level,
+                                         GLint zoffset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, GLuint texture "
+        "= %u, GLint level = %d, GLint zoffset = %d)",
+        target, attachment, textarget, texture, level, zoffset);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget textargetPacked = FromGLenum<TextureTarget>(textarget);
+        ANGLE_CAPTURE(FramebufferTexture3DOES, context, target, attachment, textargetPacked,
+                      texture, level, zoffset);
+        if (context->skipValidation() ||
+            ValidateFramebufferTexture3DOES(context, target, attachment, textargetPacked, texture,
+                                            level, zoffset))
+        {
+            context->framebufferTexture3D(target, attachment, textargetPacked, texture, level,
+                                          zoffset);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage3DOES(GLenum target,
+                               GLint level,
+                               GLenum internalformat,
+                               GLsizei width,
+                               GLsizei height,
+                               GLsizei depth,
+                               GLint border,
+                               GLenum format,
+                               GLenum type,
+                               const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, "
+        "GLenum type = 0x%X, const void *pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, format, type,
+        (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage3DOES, context, targetPacked, level, internalformat, width, height,
+                      depth, border, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage3DOES(context, targetPacked, level, internalformat, width, height,
+                                  depth, border, format, type, pixels))
+        {
+            context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
+                                format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage3DOES(GLenum target,
+                                  GLint level,
+                                  GLint xoffset,
+                                  GLint yoffset,
+                                  GLint zoffset,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLsizei depth,
+                                  GLenum format,
+                                  GLenum type,
+                                  const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLenum type = 0x%X, const void *pixels = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, type,
+        (uintptr_t)pixels);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage3DOES, context, targetPacked, level, xoffset, yoffset, zoffset,
+                      width, height, depth, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset, zoffset, width,
+                                     height, depth, format, type, pixels))
+        {
+            context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
+                                   depth, format, type, pixels);
+        }
+    }
+}
+
+// GL_OES_texture_border_clamp
+void GL_APIENTRY GetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", sampler,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSamplerParameterIivOES, context, sampler, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSamplerParameterIivOES(context, sampler, pname, params))
+        {
+            context->getSamplerParameterIiv(sampler, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", sampler,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetSamplerParameterIuivOES, context, sampler, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSamplerParameterIuivOES(context, sampler, pname, params))
+        {
+            context->getSamplerParameterIuiv(sampler, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterIivOES(GLenum target, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterIivOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameterIivOES(context, targetPacked, pname, params))
+        {
+            context->getTexParameterIiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterIuivOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameterIuivOES(context, targetPacked, pname, params))
+        {
+            context->getTexParameterIuiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLint *param = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameterIivOES, context, sampler, pname, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterIivOES(context, sampler, pname, param))
+        {
+            context->samplerParameterIiv(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLuint *param = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(SamplerParameterIuivOES, context, sampler, pname, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterIuivOES(context, sampler, pname, param))
+        {
+            context->samplerParameterIuiv(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterIivOES(GLenum target, GLenum pname, const GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterIivOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterIivOES(context, targetPacked, pname, params))
+        {
+            context->texParameterIiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLuint *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterIuivOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterIuivOES(context, targetPacked, pname, params))
+        {
+            context->texParameterIuiv(targetPacked, pname, params);
+        }
+    }
+}
+
+// GL_OES_texture_cube_map
+void GL_APIENTRY GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")", coord,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetTexGenfvOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateGetTexGenfvOES(context, coord, pname, params))
+        {
+            context->getTexGenfv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", coord,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetTexGenivOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateGetTexGenivOES(context, coord, pname, params))
+        {
+            context->getTexGeniv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")", coord,
+          pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GetTexGenxvOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateGetTexGenxvOES(context, coord, pname, params))
+        {
+            context->getTexGenxv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenfOES(GLenum coord, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", coord, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TexGenfOES, context, coord, pname, param);
+        if (context->skipValidation() || ValidateTexGenfOES(context, coord, pname, param))
+        {
+            context->texGenf(coord, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          coord, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TexGenfvOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateTexGenfvOES(context, coord, pname, params))
+        {
+            context->texGenfv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexGeniOES(GLenum coord, GLenum pname, GLint param)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLint param = %d)", coord, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TexGeniOES, context, coord, pname, param);
+        if (context->skipValidation() || ValidateTexGeniOES(context, coord, pname, param))
+        {
+            context->texGeni(coord, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenivOES(GLenum coord, GLenum pname, const GLint *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR ")",
+          coord, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TexGenivOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateTexGenivOES(context, coord, pname, params))
+        {
+            context->texGeniv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenxOES(GLenum coord, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", coord, pname, param);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TexGenxOES, context, coord, pname, param);
+        if (context->skipValidation() || ValidateTexGenxOES(context, coord, pname, param))
+        {
+            context->texGenx(coord, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")",
+          coord, pname, (uintptr_t)params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(TexGenxvOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateTexGenxvOES(context, coord, pname, params))
+        {
+            context->texGenxv(coord, pname, params);
+        }
+    }
+}
+
+// GL_OES_texture_storage_multisample_2d_array
+void GL_APIENTRY TexStorage3DMultisampleOES(GLenum target,
+                                            GLsizei samples,
+                                            GLenum internalformat,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLboolean fixedsamplelocations)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLsizei depth = %d, GLboolean fixedsamplelocations = %u)",
+        target, samples, internalformat, width, height, depth, fixedsamplelocations);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage3DMultisampleOES, context, targetPacked, samples, internalformat,
+                      width, height, depth, fixedsamplelocations);
+        if (context->skipValidation() ||
+            ValidateTexStorage3DMultisampleOES(context, targetPacked, samples, internalformat,
+                                               width, height, depth, fixedsamplelocations))
+        {
+            context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
+                                             depth, fixedsamplelocations);
+        }
+    }
+}
+
+// GL_OES_vertex_array_object
+void GL_APIENTRY BindVertexArrayOES(GLuint array)
+{
+    EVENT("(GLuint array = %u)", array);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(BindVertexArrayOES, context, array);
+        if (context->skipValidation() || ValidateBindVertexArrayOES(context, array))
+        {
+            context->bindVertexArray(array);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
+{
+    EVENT("(GLsizei n = %d, const GLuint *arrays = 0x%016" PRIxPTR ")", n, (uintptr_t)arrays);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(DeleteVertexArraysOES, context, n, arrays);
+        if (context->skipValidation() || ValidateDeleteVertexArraysOES(context, n, arrays))
+        {
+            context->deleteVertexArrays(n, arrays);
+        }
+    }
+}
+
+void GL_APIENTRY GenVertexArraysOES(GLsizei n, GLuint *arrays)
+{
+    EVENT("(GLsizei n = %d, GLuint *arrays = 0x%016" PRIxPTR ")", n, (uintptr_t)arrays);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(GenVertexArraysOES, context, n, arrays);
+        if (context->skipValidation() || ValidateGenVertexArraysOES(context, n, arrays))
+        {
+            context->genVertexArrays(n, arrays);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsVertexArrayOES(GLuint array)
+{
+    EVENT("(GLuint array = %u)", array);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(IsVertexArrayOES, context, array);
+        if (context->skipValidation() || ValidateIsVertexArrayOES(context, array))
+        {
+            return context->isVertexArray(array);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsVertexArrayOES, GLboolean>();
+}
+
+// GL_OVR_multiview
+void GL_APIENTRY FramebufferTextureMultiviewOVR(GLenum target,
+                                                GLenum attachment,
+                                                GLuint texture,
+                                                GLint level,
+                                                GLint baseViewIndex,
+                                                GLsizei numViews)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d, "
+        "GLint baseViewIndex = %d, GLsizei numViews = %d)",
+        target, attachment, texture, level, baseViewIndex, numViews);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        ANGLE_CAPTURE(FramebufferTextureMultiviewOVR, context, target, attachment, texture, level,
+                      baseViewIndex, numViews);
+        if (context->skipValidation() ||
+            ValidateFramebufferTextureMultiviewOVR(context, target, attachment, texture, level,
+                                                   baseViewIndex, numViews))
+        {
+            context->framebufferTextureMultiview(target, attachment, texture, level, baseViewIndex,
+                                                 numViews);
+        }
+    }
+}
+
+// GL_OVR_multiview2
+
+// EGL_ANGLE_explicit_context
+void GL_APIENTRY ActiveShaderProgramContextANGLE(GLeglContext ctx, GLuint pipeline, GLuint program)
+{
+    EVENT("(GLuint pipeline = %u, GLuint program = %u)", pipeline, program);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ActiveShaderProgram, context, pipeline, program);
+        if (context->skipValidation() || ValidateActiveShaderProgram(context, pipeline, program))
+        {
+            context->activeShaderProgram(pipeline, program);
+        }
+    }
+}
+
+void GL_APIENTRY ActiveTextureContextANGLE(GLeglContext ctx, GLenum texture)
+{
+    EVENT("(GLenum texture = 0x%X)", texture);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ActiveTexture, context, texture);
+        if (context->skipValidation() || ValidateActiveTexture(context, texture))
+        {
+            context->activeTexture(texture);
+        }
+    }
+}
+
+void GL_APIENTRY AlphaFuncContextANGLE(GLeglContext ctx, GLenum func, GLfloat ref)
+{
+    EVENT("(GLenum func = 0x%X, GLfloat ref = %f)", func, ref);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        AlphaTestFunc funcPacked = FromGLenum<AlphaTestFunc>(func);
+        ANGLE_CAPTURE(AlphaFunc, context, funcPacked, ref);
+        if (context->skipValidation() || ValidateAlphaFunc(context, funcPacked, ref))
+        {
+            context->alphaFunc(funcPacked, ref);
+        }
+    }
+}
+
+void GL_APIENTRY AlphaFuncxContextANGLE(GLeglContext ctx, GLenum func, GLfixed ref)
+{
+    EVENT("(GLenum func = 0x%X, GLfixed ref = 0x%X)", func, ref);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        AlphaTestFunc funcPacked = FromGLenum<AlphaTestFunc>(func);
+        ANGLE_CAPTURE(AlphaFuncx, context, funcPacked, ref);
+        if (context->skipValidation() || ValidateAlphaFuncx(context, funcPacked, ref))
+        {
+            context->alphaFuncx(funcPacked, ref);
+        }
+    }
+}
+
+void GL_APIENTRY AttachShaderContextANGLE(GLeglContext ctx, GLuint program, GLuint shader)
+{
+    EVENT("(GLuint program = %u, GLuint shader = %u)", program, shader);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(AttachShader, context, program, shader);
+        if (context->skipValidation() || ValidateAttachShader(context, program, shader))
+        {
+            context->attachShader(program, shader);
+        }
+    }
+}
+
+void GL_APIENTRY BeginQueryContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
+{
+    EVENT("(GLenum target = 0x%X, GLuint id = %u)", target, id);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(BeginQuery, context, targetPacked, id);
+        if (context->skipValidation() || ValidateBeginQuery(context, targetPacked, id))
+        {
+            context->beginQuery(targetPacked, id);
+        }
+    }
+}
+
+void GL_APIENTRY BeginQueryEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
+{
+    EVENT("(GLenum target = 0x%X, GLuint id = %u)", target, id);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(BeginQueryEXT, context, targetPacked, id);
+        if (context->skipValidation() || ValidateBeginQueryEXT(context, targetPacked, id))
+        {
+            context->beginQuery(targetPacked, id);
+        }
+    }
+}
+
+void GL_APIENTRY BeginTransformFeedbackContextANGLE(GLeglContext ctx, GLenum primitiveMode)
+{
+    EVENT("(GLenum primitiveMode = 0x%X)", primitiveMode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode primitiveModePacked = FromGLenum<PrimitiveMode>(primitiveMode);
+        ANGLE_CAPTURE(BeginTransformFeedback, context, primitiveModePacked);
+        if (context->skipValidation() ||
+            ValidateBeginTransformFeedback(context, primitiveModePacked))
+        {
+            context->beginTransformFeedback(primitiveModePacked);
+        }
+    }
+}
+
+void GL_APIENTRY BindAttribLocationContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLuint index,
+                                                const GLchar *name)
+{
+    EVENT("(GLuint program = %u, GLuint index = %u, const GLchar *name = 0x%016" PRIxPTR ")",
+          program, index, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindAttribLocation, context, program, index, name);
+        if (context->skipValidation() || ValidateBindAttribLocation(context, program, index, name))
+        {
+            context->bindAttribLocation(program, index, name);
+        }
+    }
+}
+
+void GL_APIENTRY BindBufferContextANGLE(GLeglContext ctx, GLenum target, GLuint buffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint buffer = %u)", target, buffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(BindBuffer, context, targetPacked, buffer);
+        if (context->skipValidation() || ValidateBindBuffer(context, targetPacked, buffer))
+        {
+            context->bindBuffer(targetPacked, buffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindBufferBaseContextANGLE(GLeglContext ctx,
+                                            GLenum target,
+                                            GLuint index,
+                                            GLuint buffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLuint buffer = %u)", target, index, buffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(BindBufferBase, context, targetPacked, index, buffer);
+        if (context->skipValidation() ||
+            ValidateBindBufferBase(context, targetPacked, index, buffer))
+        {
+            context->bindBufferBase(targetPacked, index, buffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindBufferRangeContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLuint index,
+                                             GLuint buffer,
+                                             GLintptr offset,
+                                             GLsizeiptr size)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLuint index = %u, GLuint buffer = %u, GLintptr offset = %llu, "
+        "GLsizeiptr size = %llu)",
+        target, index, buffer, static_cast<unsigned long long>(offset),
+        static_cast<unsigned long long>(size));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(BindBufferRange, context, targetPacked, index, buffer, offset, size);
+        if (context->skipValidation() ||
+            ValidateBindBufferRange(context, targetPacked, index, buffer, offset, size))
+        {
+            context->bindBufferRange(targetPacked, index, buffer, offset, size);
+        }
+    }
+}
+
+void GL_APIENTRY BindFragDataLocationEXTContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLuint color,
+                                                     const GLchar *name)
+{
+    EVENT("(GLuint program = %u, GLuint color = %u, const GLchar *name = 0x%016" PRIxPTR ")",
+          program, color, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindFragDataLocationEXT, context, program, color, name);
+        if (context->skipValidation() ||
+            ValidateBindFragDataLocationEXT(context, program, color, name))
+        {
+            context->bindFragDataLocation(program, color, name);
+        }
+    }
+}
+
+void GL_APIENTRY BindFragDataLocationIndexedEXTContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLuint colorNumber,
+                                                            GLuint index,
+                                                            const GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint colorNumber = %u, GLuint index = %u, const GLchar *name = "
+        "0x%016" PRIxPTR ")",
+        program, colorNumber, index, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindFragDataLocationIndexedEXT, context, program, colorNumber, index, name);
+        if (context->skipValidation() ||
+            ValidateBindFragDataLocationIndexedEXT(context, program, colorNumber, index, name))
+        {
+            context->bindFragDataLocationIndexed(program, colorNumber, index, name);
+        }
+    }
+}
+
+void GL_APIENTRY BindFramebufferContextANGLE(GLeglContext ctx, GLenum target, GLuint framebuffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint framebuffer = %u)", target, framebuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindFramebuffer, context, target, framebuffer);
+        if (context->skipValidation() || ValidateBindFramebuffer(context, target, framebuffer))
+        {
+            context->bindFramebuffer(target, framebuffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindFramebufferOESContextANGLE(GLeglContext ctx, GLenum target, GLuint framebuffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint framebuffer = %u)", target, framebuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindFramebufferOES, context, target, framebuffer);
+        if (context->skipValidation() || ValidateBindFramebufferOES(context, target, framebuffer))
+        {
+            context->bindFramebuffer(target, framebuffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindImageTextureContextANGLE(GLeglContext ctx,
+                                              GLuint unit,
+                                              GLuint texture,
+                                              GLint level,
+                                              GLboolean layered,
+                                              GLint layer,
+                                              GLenum access,
+                                              GLenum format)
+{
+    EVENT(
+        "(GLuint unit = %u, GLuint texture = %u, GLint level = %d, GLboolean layered = %u, GLint "
+        "layer = %d, GLenum access = 0x%X, GLenum format = 0x%X)",
+        unit, texture, level, layered, layer, access, format);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindImageTexture, context, unit, texture, level, layered, layer, access,
+                      format);
+        if (context->skipValidation() ||
+            ValidateBindImageTexture(context, unit, texture, level, layered, layer, access, format))
+        {
+            context->bindImageTexture(unit, texture, level, layered, layer, access, format);
+        }
+    }
+}
+
+void GL_APIENTRY BindProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
+{
+    EVENT("(GLuint pipeline = %u)", pipeline);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindProgramPipeline, context, pipeline);
+        if (context->skipValidation() || ValidateBindProgramPipeline(context, pipeline))
+        {
+            context->bindProgramPipeline(pipeline);
+        }
+    }
+}
+
+void GL_APIENTRY BindRenderbufferContextANGLE(GLeglContext ctx, GLenum target, GLuint renderbuffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint renderbuffer = %u)", target, renderbuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindRenderbuffer, context, target, renderbuffer);
+        if (context->skipValidation() || ValidateBindRenderbuffer(context, target, renderbuffer))
+        {
+            context->bindRenderbuffer(target, renderbuffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindRenderbufferOESContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLuint renderbuffer)
+{
+    EVENT("(GLenum target = 0x%X, GLuint renderbuffer = %u)", target, renderbuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindRenderbufferOES, context, target, renderbuffer);
+        if (context->skipValidation() || ValidateBindRenderbufferOES(context, target, renderbuffer))
+        {
+            context->bindRenderbuffer(target, renderbuffer);
+        }
+    }
+}
+
+void GL_APIENTRY BindSamplerContextANGLE(GLeglContext ctx, GLuint unit, GLuint sampler)
+{
+    EVENT("(GLuint unit = %u, GLuint sampler = %u)", unit, sampler);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindSampler, context, unit, sampler);
+        if (context->skipValidation() || ValidateBindSampler(context, unit, sampler))
+        {
+            context->bindSampler(unit, sampler);
+        }
+    }
+}
+
+void GL_APIENTRY BindTextureContextANGLE(GLeglContext ctx, GLenum target, GLuint texture)
+{
+    EVENT("(GLenum target = 0x%X, GLuint texture = %u)", target, texture);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(BindTexture, context, targetPacked, texture);
+        if (context->skipValidation() || ValidateBindTexture(context, targetPacked, texture))
+        {
+            context->bindTexture(targetPacked, texture);
+        }
+    }
+}
+
+void GL_APIENTRY BindTransformFeedbackContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
+{
+    EVENT("(GLenum target = 0x%X, GLuint id = %u)", target, id);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindTransformFeedback, context, target, id);
+        if (context->skipValidation() || ValidateBindTransformFeedback(context, target, id))
+        {
+            context->bindTransformFeedback(target, id);
+        }
+    }
+}
+
+void GL_APIENTRY BindVertexArrayContextANGLE(GLeglContext ctx, GLuint array)
+{
+    EVENT("(GLuint array = %u)", array);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindVertexArray, context, array);
+        if (context->skipValidation() || ValidateBindVertexArray(context, array))
+        {
+            context->bindVertexArray(array);
+        }
+    }
+}
+
+void GL_APIENTRY BindVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array)
+{
+    EVENT("(GLuint array = %u)", array);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindVertexArrayOES, context, array);
+        if (context->skipValidation() || ValidateBindVertexArrayOES(context, array))
+        {
+            context->bindVertexArray(array);
+        }
+    }
+}
+
+void GL_APIENTRY BindVertexBufferContextANGLE(GLeglContext ctx,
+                                              GLuint bindingindex,
+                                              GLuint buffer,
+                                              GLintptr offset,
+                                              GLsizei stride)
+{
+    EVENT(
+        "(GLuint bindingindex = %u, GLuint buffer = %u, GLintptr offset = %llu, GLsizei stride = "
+        "%d)",
+        bindingindex, buffer, static_cast<unsigned long long>(offset), stride);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindVertexBuffer, context, bindingindex, buffer, offset, stride);
+        if (context->skipValidation() ||
+            ValidateBindVertexBuffer(context, bindingindex, buffer, offset, stride))
+        {
+            context->bindVertexBuffer(bindingindex, buffer, offset, stride);
+        }
+    }
+}
+
+void GL_APIENTRY
+BlendColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
+          green, blue, alpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BlendColor, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateBlendColor(context, red, green, blue, alpha))
+        {
+            context->blendColor(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY BlendEquationContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BlendEquation, context, mode);
+        if (context->skipValidation() || ValidateBlendEquation(context, mode))
+        {
+            context->blendEquation(mode);
+        }
+    }
+}
+
+void GL_APIENTRY BlendEquationSeparateContextANGLE(GLeglContext ctx,
+                                                   GLenum modeRGB,
+                                                   GLenum modeAlpha)
+{
+    EVENT("(GLenum modeRGB = 0x%X, GLenum modeAlpha = 0x%X)", modeRGB, modeAlpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BlendEquationSeparate, context, modeRGB, modeAlpha);
+        if (context->skipValidation() || ValidateBlendEquationSeparate(context, modeRGB, modeAlpha))
+        {
+            context->blendEquationSeparate(modeRGB, modeAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY BlendFuncContextANGLE(GLeglContext ctx, GLenum sfactor, GLenum dfactor)
+{
+    EVENT("(GLenum sfactor = 0x%X, GLenum dfactor = 0x%X)", sfactor, dfactor);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BlendFunc, context, sfactor, dfactor);
+        if (context->skipValidation() || ValidateBlendFunc(context, sfactor, dfactor))
+        {
+            context->blendFunc(sfactor, dfactor);
+        }
+    }
+}
+
+void GL_APIENTRY BlendFuncSeparateContextANGLE(GLeglContext ctx,
+                                               GLenum sfactorRGB,
+                                               GLenum dfactorRGB,
+                                               GLenum sfactorAlpha,
+                                               GLenum dfactorAlpha)
+{
+    EVENT(
+        "(GLenum sfactorRGB = 0x%X, GLenum dfactorRGB = 0x%X, GLenum sfactorAlpha = 0x%X, GLenum "
+        "dfactorAlpha = 0x%X)",
+        sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BlendFuncSeparate, context, sfactorRGB, dfactorRGB, sfactorAlpha,
+                      dfactorAlpha);
+        if (context->skipValidation() ||
+            ValidateBlendFuncSeparate(context, sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha))
+        {
+            context->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY BlitFramebufferContextANGLE(GLeglContext ctx,
+                                             GLint srcX0,
+                                             GLint srcY0,
+                                             GLint srcX1,
+                                             GLint srcY1,
+                                             GLint dstX0,
+                                             GLint dstY0,
+                                             GLint dstX1,
+                                             GLint dstY1,
+                                             GLbitfield mask,
+                                             GLenum filter)
+{
+    EVENT(
+        "(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, GLint dstX0 = "
+        "%d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask = 0x%X, GLenum "
+        "filter = 0x%X)",
+        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BlitFramebuffer, context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
+                      dstY1, mask, filter);
+        if (context->skipValidation() ||
+            ValidateBlitFramebuffer(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
+                                    mask, filter))
+        {
+            context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
+                                     filter);
+        }
+    }
+}
+
+void GL_APIENTRY BlitFramebufferANGLEContextANGLE(GLeglContext ctx,
+                                                  GLint srcX0,
+                                                  GLint srcY0,
+                                                  GLint srcX1,
+                                                  GLint srcY1,
+                                                  GLint dstX0,
+                                                  GLint dstY0,
+                                                  GLint dstX1,
+                                                  GLint dstY1,
+                                                  GLbitfield mask,
+                                                  GLenum filter)
+{
+    EVENT(
+        "(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, GLint dstX0 = "
+        "%d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask = 0x%X, GLenum "
+        "filter = 0x%X)",
+        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BlitFramebufferANGLE, context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+                      dstX1, dstY1, mask, filter);
+        if (context->skipValidation() ||
+            ValidateBlitFramebufferANGLE(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
+                                         dstY1, mask, filter))
+        {
+            context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
+                                     filter);
+        }
+    }
+}
+
+void GL_APIENTRY BufferDataContextANGLE(GLeglContext ctx,
+                                        GLenum target,
+                                        GLsizeiptr size,
+                                        const void *data,
+                                        GLenum usage)
+{
+    EVENT("(GLenum target = 0x%X, GLsizeiptr size = %llu, const void *data = 0x%016" PRIxPTR
+          ", GLenum usage = 0x%X)",
+          target, static_cast<unsigned long long>(size), (uintptr_t)data, usage);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        BufferUsage usagePacked    = FromGLenum<BufferUsage>(usage);
+        ANGLE_CAPTURE(BufferData, context, targetPacked, size, data, usagePacked);
+        if (context->skipValidation() ||
+            ValidateBufferData(context, targetPacked, size, data, usagePacked))
+        {
+            context->bufferData(targetPacked, size, data, usagePacked);
+        }
+    }
+}
+
+void GL_APIENTRY BufferStorageMemEXTContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLsizeiptr size,
+                                                 GLuint memory,
+                                                 GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizeiptr size = %llu, GLuint memory = %u, GLuint64 offset = "
+        "%llu)",
+        target, static_cast<unsigned long long>(size), memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(BufferStorageMemEXT, context, targetPacked, size, memory, offset);
+        if (context->skipValidation() ||
+            ValidateBufferStorageMemEXT(context, targetPacked, size, memory, offset))
+        {
+            context->bufferStorageMem(targetPacked, size, memory, offset);
+        }
+    }
+}
+
+void GL_APIENTRY BufferSubDataContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLintptr offset,
+                                           GLsizeiptr size,
+                                           const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr size = %llu, const void *data = "
+        "0x%016" PRIxPTR ")",
+        target, static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
+        (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(BufferSubData, context, targetPacked, offset, size, data);
+        if (context->skipValidation() ||
+            ValidateBufferSubData(context, targetPacked, offset, size, data))
+        {
+            context->bufferSubData(targetPacked, offset, size, data);
+        }
+    }
+}
+
+GLenum GL_APIENTRY CheckFramebufferStatusContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CheckFramebufferStatus, context, target);
+        if (context->skipValidation() || ValidateCheckFramebufferStatus(context, target))
+        {
+            return context->checkFramebufferStatus(target);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CheckFramebufferStatus, GLenum>();
+}
+
+GLenum GL_APIENTRY CheckFramebufferStatusOESContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CheckFramebufferStatusOES, context, target);
+        if (context->skipValidation() || ValidateCheckFramebufferStatusOES(context, target))
+        {
+            return context->checkFramebufferStatus(target);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CheckFramebufferStatusOES, GLenum>();
+}
+
+void GL_APIENTRY ClearContextANGLE(GLeglContext ctx, GLbitfield mask)
+{
+    EVENT("(GLbitfield mask = 0x%X)", mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Clear, context, mask);
+        if (context->skipValidation() || ValidateClear(context, mask))
+        {
+            context->clear(mask);
+        }
+    }
+}
+
+void GL_APIENTRY ClearBufferfiContextANGLE(GLeglContext ctx,
+                                           GLenum buffer,
+                                           GLint drawbuffer,
+                                           GLfloat depth,
+                                           GLint stencil)
+{
+    EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, GLfloat depth = %f, GLint stencil = %d)",
+          buffer, drawbuffer, depth, stencil);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearBufferfi, context, buffer, drawbuffer, depth, stencil);
+        if (context->skipValidation() ||
+            ValidateClearBufferfi(context, buffer, drawbuffer, depth, stencil))
+        {
+            context->clearBufferfi(buffer, drawbuffer, depth, stencil);
+        }
+    }
+}
+
+void GL_APIENTRY ClearBufferfvContextANGLE(GLeglContext ctx,
+                                           GLenum buffer,
+                                           GLint drawbuffer,
+                                           const GLfloat *value)
+{
+    EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          buffer, drawbuffer, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearBufferfv, context, buffer, drawbuffer, value);
+        if (context->skipValidation() || ValidateClearBufferfv(context, buffer, drawbuffer, value))
+        {
+            context->clearBufferfv(buffer, drawbuffer, value);
+        }
+    }
+}
+
+void GL_APIENTRY ClearBufferivContextANGLE(GLeglContext ctx,
+                                           GLenum buffer,
+                                           GLint drawbuffer,
+                                           const GLint *value)
+{
+    EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          buffer, drawbuffer, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearBufferiv, context, buffer, drawbuffer, value);
+        if (context->skipValidation() || ValidateClearBufferiv(context, buffer, drawbuffer, value))
+        {
+            context->clearBufferiv(buffer, drawbuffer, value);
+        }
+    }
+}
+
+void GL_APIENTRY ClearBufferuivContextANGLE(GLeglContext ctx,
+                                            GLenum buffer,
+                                            GLint drawbuffer,
+                                            const GLuint *value)
+{
+    EVENT("(GLenum buffer = 0x%X, GLint drawbuffer = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          buffer, drawbuffer, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearBufferuiv, context, buffer, drawbuffer, value);
+        if (context->skipValidation() || ValidateClearBufferuiv(context, buffer, drawbuffer, value))
+        {
+            context->clearBufferuiv(buffer, drawbuffer, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+ClearColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
+          green, blue, alpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearColor, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateClearColor(context, red, green, blue, alpha))
+        {
+            context->clearColor(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY
+ClearColorxContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+    EVENT("(GLfixed red = 0x%X, GLfixed green = 0x%X, GLfixed blue = 0x%X, GLfixed alpha = 0x%X)",
+          red, green, blue, alpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearColorx, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateClearColorx(context, red, green, blue, alpha))
+        {
+            context->clearColorx(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY ClearDepthfContextANGLE(GLeglContext ctx, GLfloat d)
+{
+    EVENT("(GLfloat d = %f)", d);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearDepthf, context, d);
+        if (context->skipValidation() || ValidateClearDepthf(context, d))
+        {
+            context->clearDepthf(d);
+        }
+    }
+}
+
+void GL_APIENTRY ClearDepthxContextANGLE(GLeglContext ctx, GLfixed depth)
+{
+    EVENT("(GLfixed depth = 0x%X)", depth);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearDepthx, context, depth);
+        if (context->skipValidation() || ValidateClearDepthx(context, depth))
+        {
+            context->clearDepthx(depth);
+        }
+    }
+}
+
+void GL_APIENTRY ClearStencilContextANGLE(GLeglContext ctx, GLint s)
+{
+    EVENT("(GLint s = %d)", s);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClearStencil, context, s);
+        if (context->skipValidation() || ValidateClearStencil(context, s))
+        {
+            context->clearStencil(s);
+        }
+    }
+}
+
+void GL_APIENTRY ClientActiveTextureContextANGLE(GLeglContext ctx, GLenum texture)
+{
+    EVENT("(GLenum texture = 0x%X)", texture);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClientActiveTexture, context, texture);
+        if (context->skipValidation() || ValidateClientActiveTexture(context, texture))
+        {
+            context->clientActiveTexture(texture);
+        }
+    }
+}
+
+GLenum GL_APIENTRY ClientWaitSyncContextANGLE(GLeglContext ctx,
+                                              GLsync sync,
+                                              GLbitfield flags,
+                                              GLuint64 timeout)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR ", GLbitfield flags = 0x%X, GLuint64 timeout = %llu)",
+          (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClientWaitSync, context, sync, flags, timeout);
+        if (context->skipValidation() || ValidateClientWaitSync(context, sync, flags, timeout))
+        {
+            return context->clientWaitSync(sync, flags, timeout);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::ClientWaitSync, GLenum>();
+}
+
+void GL_APIENTRY ClipPlanefContextANGLE(GLeglContext ctx, GLenum p, const GLfloat *eqn)
+{
+    EVENT("(GLenum p = 0x%X, const GLfloat *eqn = 0x%016" PRIxPTR ")", p, (uintptr_t)eqn);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClipPlanef, context, p, eqn);
+        if (context->skipValidation() || ValidateClipPlanef(context, p, eqn))
+        {
+            context->clipPlanef(p, eqn);
+        }
+    }
+}
+
+void GL_APIENTRY ClipPlanexContextANGLE(GLeglContext ctx, GLenum plane, const GLfixed *equation)
+{
+    EVENT("(GLenum plane = 0x%X, const GLfixed *equation = 0x%016" PRIxPTR ")", plane,
+          (uintptr_t)equation);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ClipPlanex, context, plane, equation);
+        if (context->skipValidation() || ValidateClipPlanex(context, plane, equation))
+        {
+            context->clipPlanex(plane, equation);
+        }
+    }
+}
+
+void GL_APIENTRY
+Color4fContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    EVENT("(GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f)", red,
+          green, blue, alpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Color4f, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateColor4f(context, red, green, blue, alpha))
+        {
+            context->color4f(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY
+Color4ubContextANGLE(GLeglContext ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+    EVENT("(GLubyte red = %d, GLubyte green = %d, GLubyte blue = %d, GLubyte alpha = %d)", red,
+          green, blue, alpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Color4ub, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateColor4ub(context, red, green, blue, alpha))
+        {
+            context->color4ub(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY
+Color4xContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+    EVENT("(GLfixed red = 0x%X, GLfixed green = 0x%X, GLfixed blue = 0x%X, GLfixed alpha = 0x%X)",
+          red, green, blue, alpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Color4x, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateColor4x(context, red, green, blue, alpha))
+        {
+            context->color4x(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY ColorMaskContextANGLE(GLeglContext ctx,
+                                       GLboolean red,
+                                       GLboolean green,
+                                       GLboolean blue,
+                                       GLboolean alpha)
+{
+    EVENT("(GLboolean red = %u, GLboolean green = %u, GLboolean blue = %u, GLboolean alpha = %u)",
+          red, green, blue, alpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ColorMask, context, red, green, blue, alpha);
+        if (context->skipValidation() || ValidateColorMask(context, red, green, blue, alpha))
+        {
+            context->colorMask(red, green, blue, alpha);
+        }
+    }
+}
+
+void GL_APIENTRY ColorPointerContextANGLE(GLeglContext ctx,
+                                          GLint size,
+                                          GLenum type,
+                                          GLsizei stride,
+                                          const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(ColorPointer, context, size, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateColorPointer(context, size, typePacked, stride, pointer))
+        {
+            context->colorPointer(size, typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY CompileShaderContextANGLE(GLeglContext ctx, GLuint shader)
+{
+    EVENT("(GLuint shader = %u)", shader);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CompileShader, context, shader);
+        if (context->skipValidation() || ValidateCompileShader(context, shader))
+        {
+            context->compileShader(shader);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexImage2DContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLint level,
+                                                  GLenum internalformat,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLint border,
+                                                  GLsizei imageSize,
+                                                  const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const void *data = "
+        "0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, border, imageSize, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage2D, context, targetPacked, level, internalformat, width,
+                      height, border, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexImage2D(context, targetPacked, level, internalformat, width,
+                                         height, border, imageSize, data))
+        {
+            context->compressedTexImage2D(targetPacked, level, internalformat, width, height,
+                                          border, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexImage3DContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLint level,
+                                                  GLenum internalformat,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLsizei depth,
+                                                  GLint border,
+                                                  GLsizei imageSize,
+                                                  const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, "
+        "const void *data = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, imageSize, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage3D, context, targetPacked, level, internalformat, width,
+                      height, depth, border, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexImage3D(context, targetPacked, level, internalformat, width,
+                                         height, depth, border, imageSize, data))
+        {
+            context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
+                                          border, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexImage3DOESContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLint level,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLsizei depth,
+                                                     GLint border,
+                                                     GLsizei imageSize,
+                                                     const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, "
+        "const void *data = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, imageSize, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage3DOES, context, targetPacked, level, internalformat, width,
+                      height, depth, border, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexImage3DOES(context, targetPacked, level, internalformat, width,
+                                            height, depth, border, imageSize, data))
+        {
+            context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth,
+                                          border, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage2DContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLint level,
+                                                     GLint xoffset,
+                                                     GLint yoffset,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLenum format,
+                                                     GLsizei imageSize,
+                                                     const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei "
+        "width = %d, GLsizei height = %d, GLenum format = 0x%X, GLsizei imageSize = %d, const void "
+        "*data = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, width, height, format, imageSize, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage2D, context, targetPacked, level, xoffset, yoffset,
+                      width, height, format, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexSubImage2D(context, targetPacked, level, xoffset, yoffset, width,
+                                            height, format, imageSize, data))
+        {
+            context->compressedTexSubImage2D(targetPacked, level, xoffset, yoffset, width, height,
+                                             format, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage3DContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLint level,
+                                                     GLint xoffset,
+                                                     GLint yoffset,
+                                                     GLint zoffset,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLsizei depth,
+                                                     GLenum format,
+                                                     GLsizei imageSize,
+                                                     const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize,
+        (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage3D, context, targetPacked, level, xoffset, yoffset,
+                      zoffset, width, height, depth, format, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexSubImage3D(context, targetPacked, level, xoffset, yoffset, zoffset,
+                                            width, height, depth, format, imageSize, data))
+        {
+            context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
+                                             height, depth, format, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLint level,
+                                                        GLint xoffset,
+                                                        GLint yoffset,
+                                                        GLint zoffset,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLsizei depth,
+                                                        GLenum format,
+                                                        GLsizei imageSize,
+                                                        const void *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLsizei imageSize = %d, const void *data = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize,
+        (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage3DOES, context, targetPacked, level, xoffset, yoffset,
+                      zoffset, width, height, depth, format, imageSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset,
+                                               zoffset, width, height, depth, format, imageSize,
+                                               data))
+        {
+            context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width,
+                                             height, depth, format, imageSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CopyBufferSubDataContextANGLE(GLeglContext ctx,
+                                               GLenum readTarget,
+                                               GLenum writeTarget,
+                                               GLintptr readOffset,
+                                               GLintptr writeOffset,
+                                               GLsizeiptr size)
+{
+    EVENT(
+        "(GLenum readTarget = 0x%X, GLenum writeTarget = 0x%X, GLintptr readOffset = %llu, "
+        "GLintptr writeOffset = %llu, GLsizeiptr size = %llu)",
+        readTarget, writeTarget, static_cast<unsigned long long>(readOffset),
+        static_cast<unsigned long long>(writeOffset), static_cast<unsigned long long>(size));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding readTargetPacked  = FromGLenum<BufferBinding>(readTarget);
+        BufferBinding writeTargetPacked = FromGLenum<BufferBinding>(writeTarget);
+        ANGLE_CAPTURE(CopyBufferSubData, context, readTargetPacked, writeTargetPacked, readOffset,
+                      writeOffset, size);
+        if (context->skipValidation() ||
+            ValidateCopyBufferSubData(context, readTargetPacked, writeTargetPacked, readOffset,
+                                      writeOffset, size))
+        {
+            context->copyBufferSubData(readTargetPacked, writeTargetPacked, readOffset, writeOffset,
+                                       size);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexImage2DContextANGLE(GLeglContext ctx,
+                                            GLenum target,
+                                            GLint level,
+                                            GLenum internalformat,
+                                            GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLint border)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLint x = %d, "
+        "GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d)",
+        target, level, internalformat, x, y, width, height, border);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CopyTexImage2D, context, targetPacked, level, internalformat, x, y, width,
+                      height, border);
+        if (context->skipValidation() ||
+            ValidateCopyTexImage2D(context, targetPacked, level, internalformat, x, y, width,
+                                   height, border))
+        {
+            context->copyTexImage2D(targetPacked, level, internalformat, x, y, width, height,
+                                    border);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexSubImage2DContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLint level,
+                                               GLint xoffset,
+                                               GLint yoffset,
+                                               GLint x,
+                                               GLint y,
+                                               GLsizei width,
+                                               GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint x "
+        "= %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+        target, level, xoffset, yoffset, x, y, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CopyTexSubImage2D, context, targetPacked, level, xoffset, yoffset, x, y,
+                      width, height);
+        if (context->skipValidation() ||
+            ValidateCopyTexSubImage2D(context, targetPacked, level, xoffset, yoffset, x, y, width,
+                                      height))
+        {
+            context->copyTexSubImage2D(targetPacked, level, xoffset, yoffset, x, y, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexSubImage3DContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLint level,
+                                               GLint xoffset,
+                                               GLint yoffset,
+                                               GLint zoffset,
+                                               GLint x,
+                                               GLint y,
+                                               GLsizei width,
+                                               GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+        target, level, xoffset, yoffset, zoffset, x, y, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CopyTexSubImage3D, context, targetPacked, level, xoffset, yoffset, zoffset, x,
+                      y, width, height);
+        if (context->skipValidation() ||
+            ValidateCopyTexSubImage3D(context, targetPacked, level, xoffset, yoffset, zoffset, x, y,
+                                      width, height))
+        {
+            context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
+                                       height);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLint level,
+                                                  GLint xoffset,
+                                                  GLint yoffset,
+                                                  GLint zoffset,
+                                                  GLint x,
+                                                  GLint y,
+                                                  GLsizei width,
+                                                  GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+        target, level, xoffset, yoffset, zoffset, x, y, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CopyTexSubImage3DOES, context, targetPacked, level, xoffset, yoffset, zoffset,
+                      x, y, width, height);
+        if (context->skipValidation() ||
+            ValidateCopyTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset, zoffset, x,
+                                         y, width, height))
+        {
+            context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width,
+                                       height);
+        }
+    }
+}
+
+void GL_APIENTRY CreateMemoryObjectsEXTContextANGLE(GLeglContext ctx,
+                                                    GLsizei n,
+                                                    GLuint *memoryObjects)
+{
+    EVENT("(GLsizei n = %d, GLuint *memoryObjects = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)memoryObjects);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CreateMemoryObjectsEXT, context, n, memoryObjects);
+        if (context->skipValidation() || ValidateCreateMemoryObjectsEXT(context, n, memoryObjects))
+        {
+            context->createMemoryObjects(n, memoryObjects);
+        }
+    }
+}
+
+GLuint GL_APIENTRY CreateProgramContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CreateProgram, context);
+        if (context->skipValidation() || ValidateCreateProgram(context))
+        {
+            return context->createProgram();
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CreateProgram, GLuint>();
+}
+
+GLuint GL_APIENTRY CreateShaderContextANGLE(GLeglContext ctx, GLenum type)
+{
+    EVENT("(GLenum type = 0x%X)", type);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ShaderType typePacked = FromGLenum<ShaderType>(type);
+        ANGLE_CAPTURE(CreateShader, context, typePacked);
+        if (context->skipValidation() || ValidateCreateShader(context, typePacked))
+        {
+            return context->createShader(typePacked);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CreateShader, GLuint>();
+}
+
+GLuint GL_APIENTRY CreateShaderProgramvContextANGLE(GLeglContext ctx,
+                                                    GLenum type,
+                                                    GLsizei count,
+                                                    const GLchar *const *strings)
+{
+    EVENT("(GLenum type = 0x%X, GLsizei count = %d, const GLchar *const*strings = 0x%016" PRIxPTR
+          ")",
+          type, count, (uintptr_t)strings);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ShaderType typePacked = FromGLenum<ShaderType>(type);
+        ANGLE_CAPTURE(CreateShaderProgramv, context, typePacked, count, strings);
+        if (context->skipValidation() ||
+            ValidateCreateShaderProgramv(context, typePacked, count, strings))
+        {
+            return context->createShaderProgramv(typePacked, count, strings);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
+}
+
+void GL_APIENTRY CullFaceContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        CullFaceMode modePacked = FromGLenum<CullFaceMode>(mode);
+        ANGLE_CAPTURE(CullFace, context, modePacked);
+        if (context->skipValidation() || ValidateCullFace(context, modePacked))
+        {
+            context->cullFace(modePacked);
+        }
+    }
+}
+
+void GL_APIENTRY CurrentPaletteMatrixOESContextANGLE(GLeglContext ctx, GLuint matrixpaletteindex)
+{
+    EVENT("(GLuint matrixpaletteindex = %u)", matrixpaletteindex);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CurrentPaletteMatrixOES, context, matrixpaletteindex);
+        if (context->skipValidation() ||
+            ValidateCurrentPaletteMatrixOES(context, matrixpaletteindex))
+        {
+            context->currentPaletteMatrix(matrixpaletteindex);
+        }
+    }
+}
+
+void GL_APIENTRY DebugMessageCallbackKHRContextANGLE(GLeglContext ctx,
+                                                     GLDEBUGPROCKHR callback,
+                                                     const void *userParam)
+{
+    EVENT("(GLDEBUGPROCKHR callback = 0x%016" PRIxPTR ", const void *userParam = 0x%016" PRIxPTR
+          ")",
+          (uintptr_t)callback, (uintptr_t)userParam);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DebugMessageCallbackKHR, context, callback, userParam);
+        if (context->skipValidation() ||
+            ValidateDebugMessageCallbackKHR(context, callback, userParam))
+        {
+            context->debugMessageCallback(callback, userParam);
+        }
+    }
+}
+
+void GL_APIENTRY DebugMessageControlKHRContextANGLE(GLeglContext ctx,
+                                                    GLenum source,
+                                                    GLenum type,
+                                                    GLenum severity,
+                                                    GLsizei count,
+                                                    const GLuint *ids,
+                                                    GLboolean enabled)
+{
+    EVENT(
+        "(GLenum source = 0x%X, GLenum type = 0x%X, GLenum severity = 0x%X, GLsizei count = %d, "
+        "const GLuint *ids = 0x%016" PRIxPTR ", GLboolean enabled = %u)",
+        source, type, severity, count, (uintptr_t)ids, enabled);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DebugMessageControlKHR, context, source, type, severity, count, ids, enabled);
+        if (context->skipValidation() ||
+            ValidateDebugMessageControlKHR(context, source, type, severity, count, ids, enabled))
+        {
+            context->debugMessageControl(source, type, severity, count, ids, enabled);
+        }
+    }
+}
+
+void GL_APIENTRY DebugMessageInsertKHRContextANGLE(GLeglContext ctx,
+                                                   GLenum source,
+                                                   GLenum type,
+                                                   GLuint id,
+                                                   GLenum severity,
+                                                   GLsizei length,
+                                                   const GLchar *buf)
+{
+    EVENT(
+        "(GLenum source = 0x%X, GLenum type = 0x%X, GLuint id = %u, GLenum severity = 0x%X, "
+        "GLsizei length = %d, const GLchar *buf = 0x%016" PRIxPTR ")",
+        source, type, id, severity, length, (uintptr_t)buf);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DebugMessageInsertKHR, context, source, type, id, severity, length, buf);
+        if (context->skipValidation() ||
+            ValidateDebugMessageInsertKHR(context, source, type, id, severity, length, buf))
+        {
+            context->debugMessageInsert(source, type, id, severity, length, buf);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteBuffersContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *buffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *buffers = 0x%016" PRIxPTR ")", n, (uintptr_t)buffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteBuffers, context, n, buffers);
+        if (context->skipValidation() || ValidateDeleteBuffers(context, n, buffers))
+        {
+            context->deleteBuffers(n, buffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteFencesNVContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *fences)
+{
+    EVENT("(GLsizei n = %d, const GLuint *fences = 0x%016" PRIxPTR ")", n, (uintptr_t)fences);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteFencesNV, context, n, fences);
+        if (context->skipValidation() || ValidateDeleteFencesNV(context, n, fences))
+        {
+            context->deleteFencesNV(n, fences);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteFramebuffersContextANGLE(GLeglContext ctx,
+                                                GLsizei n,
+                                                const GLuint *framebuffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *framebuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)framebuffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteFramebuffers, context, n, framebuffers);
+        if (context->skipValidation() || ValidateDeleteFramebuffers(context, n, framebuffers))
+        {
+            context->deleteFramebuffers(n, framebuffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteFramebuffersOESContextANGLE(GLeglContext ctx,
+                                                   GLsizei n,
+                                                   const GLuint *framebuffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *framebuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)framebuffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteFramebuffersOES, context, n, framebuffers);
+        if (context->skipValidation() || ValidateDeleteFramebuffersOES(context, n, framebuffers))
+        {
+            context->deleteFramebuffers(n, framebuffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteMemoryObjectsEXTContextANGLE(GLeglContext ctx,
+                                                    GLsizei n,
+                                                    const GLuint *memoryObjects)
+{
+    EVENT("(GLsizei n = %d, const GLuint *memoryObjects = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)memoryObjects);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteMemoryObjectsEXT, context, n, memoryObjects);
+        if (context->skipValidation() || ValidateDeleteMemoryObjectsEXT(context, n, memoryObjects))
+        {
+            context->deleteMemoryObjects(n, memoryObjects);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteProgram, context, program);
+        if (context->skipValidation() || ValidateDeleteProgram(context, program))
+        {
+            context->deleteProgram(program);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteProgramPipelinesContextANGLE(GLeglContext ctx,
+                                                    GLsizei n,
+                                                    const GLuint *pipelines)
+{
+    EVENT("(GLsizei n = %d, const GLuint *pipelines = 0x%016" PRIxPTR ")", n, (uintptr_t)pipelines);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteProgramPipelines, context, n, pipelines);
+        if (context->skipValidation() || ValidateDeleteProgramPipelines(context, n, pipelines))
+        {
+            context->deleteProgramPipelines(n, pipelines);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteQueriesContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteQueries, context, n, ids);
+        if (context->skipValidation() || ValidateDeleteQueries(context, n, ids))
+        {
+            context->deleteQueries(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteQueriesEXT, context, n, ids);
+        if (context->skipValidation() || ValidateDeleteQueriesEXT(context, n, ids))
+        {
+            context->deleteQueries(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteRenderbuffersContextANGLE(GLeglContext ctx,
+                                                 GLsizei n,
+                                                 const GLuint *renderbuffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *renderbuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)renderbuffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteRenderbuffers, context, n, renderbuffers);
+        if (context->skipValidation() || ValidateDeleteRenderbuffers(context, n, renderbuffers))
+        {
+            context->deleteRenderbuffers(n, renderbuffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteRenderbuffersOESContextANGLE(GLeglContext ctx,
+                                                    GLsizei n,
+                                                    const GLuint *renderbuffers)
+{
+    EVENT("(GLsizei n = %d, const GLuint *renderbuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)renderbuffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteRenderbuffersOES, context, n, renderbuffers);
+        if (context->skipValidation() || ValidateDeleteRenderbuffersOES(context, n, renderbuffers))
+        {
+            context->deleteRenderbuffers(n, renderbuffers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteSamplersContextANGLE(GLeglContext ctx, GLsizei count, const GLuint *samplers)
+{
+    EVENT("(GLsizei count = %d, const GLuint *samplers = 0x%016" PRIxPTR ")", count,
+          (uintptr_t)samplers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteSamplers, context, count, samplers);
+        if (context->skipValidation() || ValidateDeleteSamplers(context, count, samplers))
+        {
+            context->deleteSamplers(count, samplers);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteSemaphoresEXTContextANGLE(GLeglContext ctx,
+                                                 GLsizei n,
+                                                 const GLuint *semaphores)
+{
+    EVENT("(GLsizei n = %d, const GLuint *semaphores = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)semaphores);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteSemaphoresEXT, context, n, semaphores);
+        if (context->skipValidation() || ValidateDeleteSemaphoresEXT(context, n, semaphores))
+        {
+            context->deleteSemaphores(n, semaphores);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteShaderContextANGLE(GLeglContext ctx, GLuint shader)
+{
+    EVENT("(GLuint shader = %u)", shader);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteShader, context, shader);
+        if (context->skipValidation() || ValidateDeleteShader(context, shader))
+        {
+            context->deleteShader(shader);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteSyncContextANGLE(GLeglContext ctx, GLsync sync)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR ")", (uintptr_t)sync);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteSync, context, sync);
+        if (context->skipValidation() || ValidateDeleteSync(context, sync))
+        {
+            context->deleteSync(sync);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteTexturesContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *textures)
+{
+    EVENT("(GLsizei n = %d, const GLuint *textures = 0x%016" PRIxPTR ")", n, (uintptr_t)textures);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteTextures, context, n, textures);
+        if (context->skipValidation() || ValidateDeleteTextures(context, n, textures))
+        {
+            context->deleteTextures(n, textures);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteTransformFeedbacksContextANGLE(GLeglContext ctx,
+                                                      GLsizei n,
+                                                      const GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteTransformFeedbacks, context, n, ids);
+        if (context->skipValidation() || ValidateDeleteTransformFeedbacks(context, n, ids))
+        {
+            context->deleteTransformFeedbacks(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteVertexArraysContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *arrays)
+{
+    EVENT("(GLsizei n = %d, const GLuint *arrays = 0x%016" PRIxPTR ")", n, (uintptr_t)arrays);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteVertexArrays, context, n, arrays);
+        if (context->skipValidation() || ValidateDeleteVertexArrays(context, n, arrays))
+        {
+            context->deleteVertexArrays(n, arrays);
+        }
+    }
+}
+
+void GL_APIENTRY DeleteVertexArraysOESContextANGLE(GLeglContext ctx,
+                                                   GLsizei n,
+                                                   const GLuint *arrays)
+{
+    EVENT("(GLsizei n = %d, const GLuint *arrays = 0x%016" PRIxPTR ")", n, (uintptr_t)arrays);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeleteVertexArraysOES, context, n, arrays);
+        if (context->skipValidation() || ValidateDeleteVertexArraysOES(context, n, arrays))
+        {
+            context->deleteVertexArrays(n, arrays);
+        }
+    }
+}
+
+void GL_APIENTRY DepthFuncContextANGLE(GLeglContext ctx, GLenum func)
+{
+    EVENT("(GLenum func = 0x%X)", func);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DepthFunc, context, func);
+        if (context->skipValidation() || ValidateDepthFunc(context, func))
+        {
+            context->depthFunc(func);
+        }
+    }
+}
+
+void GL_APIENTRY DepthMaskContextANGLE(GLeglContext ctx, GLboolean flag)
+{
+    EVENT("(GLboolean flag = %u)", flag);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DepthMask, context, flag);
+        if (context->skipValidation() || ValidateDepthMask(context, flag))
+        {
+            context->depthMask(flag);
+        }
+    }
+}
+
+void GL_APIENTRY DepthRangefContextANGLE(GLeglContext ctx, GLfloat n, GLfloat f)
+{
+    EVENT("(GLfloat n = %f, GLfloat f = %f)", n, f);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DepthRangef, context, n, f);
+        if (context->skipValidation() || ValidateDepthRangef(context, n, f))
+        {
+            context->depthRangef(n, f);
+        }
+    }
+}
+
+void GL_APIENTRY DepthRangexContextANGLE(GLeglContext ctx, GLfixed n, GLfixed f)
+{
+    EVENT("(GLfixed n = 0x%X, GLfixed f = 0x%X)", n, f);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DepthRangex, context, n, f);
+        if (context->skipValidation() || ValidateDepthRangex(context, n, f))
+        {
+            context->depthRangex(n, f);
+        }
+    }
+}
+
+void GL_APIENTRY DetachShaderContextANGLE(GLeglContext ctx, GLuint program, GLuint shader)
+{
+    EVENT("(GLuint program = %u, GLuint shader = %u)", program, shader);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DetachShader, context, program, shader);
+        if (context->skipValidation() || ValidateDetachShader(context, program, shader))
+        {
+            context->detachShader(program, shader);
+        }
+    }
+}
+
+void GL_APIENTRY DisableContextANGLE(GLeglContext ctx, GLenum cap)
+{
+    EVENT("(GLenum cap = 0x%X)", cap);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Disable, context, cap);
+        if (context->skipValidation() || ValidateDisable(context, cap))
+        {
+            context->disable(cap);
+        }
+    }
+}
+
+void GL_APIENTRY DisableClientStateContextANGLE(GLeglContext ctx, GLenum array)
+{
+    EVENT("(GLenum array = 0x%X)", array);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ClientVertexArrayType arrayPacked = FromGLenum<ClientVertexArrayType>(array);
+        ANGLE_CAPTURE(DisableClientState, context, arrayPacked);
+        if (context->skipValidation() || ValidateDisableClientState(context, arrayPacked))
+        {
+            context->disableClientState(arrayPacked);
+        }
+    }
+}
+
+void GL_APIENTRY DisableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index)
+{
+    EVENT("(GLuint index = %u)", index);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DisableVertexAttribArray, context, index);
+        if (context->skipValidation() || ValidateDisableVertexAttribArray(context, index))
+        {
+            context->disableVertexAttribArray(index);
+        }
+    }
+}
+
+void GL_APIENTRY DiscardFramebufferEXTContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLsizei numAttachments,
+                                                   const GLenum *attachments)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum *attachments = "
+        "0x%016" PRIxPTR ")",
+        target, numAttachments, (uintptr_t)attachments);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DiscardFramebufferEXT, context, target, numAttachments, attachments);
+        if (context->skipValidation() ||
+            ValidateDiscardFramebufferEXT(context, target, numAttachments, attachments))
+        {
+            context->discardFramebuffer(target, numAttachments, attachments);
+        }
+    }
+}
+
+void GL_APIENTRY DispatchComputeContextANGLE(GLeglContext ctx,
+                                             GLuint num_groups_x,
+                                             GLuint num_groups_y,
+                                             GLuint num_groups_z)
+{
+    EVENT("(GLuint num_groups_x = %u, GLuint num_groups_y = %u, GLuint num_groups_z = %u)",
+          num_groups_x, num_groups_y, num_groups_z);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DispatchCompute, context, num_groups_x, num_groups_y, num_groups_z);
+        if (context->skipValidation() ||
+            ValidateDispatchCompute(context, num_groups_x, num_groups_y, num_groups_z))
+        {
+            context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+        }
+    }
+}
+
+void GL_APIENTRY DispatchComputeIndirectContextANGLE(GLeglContext ctx, GLintptr indirect)
+{
+    EVENT("(GLintptr indirect = %llu)", static_cast<unsigned long long>(indirect));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DispatchComputeIndirect, context, indirect);
+        if (context->skipValidation() || ValidateDispatchComputeIndirect(context, indirect))
+        {
+            context->dispatchComputeIndirect(indirect);
+        }
+    }
+}
+
+void GL_APIENTRY DrawArraysContextANGLE(GLeglContext ctx, GLenum mode, GLint first, GLsizei count)
+{
+    EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d)", mode, first, count);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArrays, context, modePacked, first, count);
+        if (context->skipValidation() || ValidateDrawArrays(context, modePacked, first, count))
+        {
+            context->drawArrays(modePacked, first, count);
+        }
+    }
+}
+
+void GL_APIENTRY DrawArraysIndirectContextANGLE(GLeglContext ctx, GLenum mode, const void *indirect)
+{
+    EVENT("(GLenum mode = 0x%X, const void *indirect = 0x%016" PRIxPTR ")", mode,
+          (uintptr_t)indirect);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArraysIndirect, context, modePacked, indirect);
+        if (context->skipValidation() || ValidateDrawArraysIndirect(context, modePacked, indirect))
+        {
+            context->drawArraysIndirect(modePacked, indirect);
+        }
+    }
+}
+
+void GL_APIENTRY DrawArraysInstancedContextANGLE(GLeglContext ctx,
+                                                 GLenum mode,
+                                                 GLint first,
+                                                 GLsizei count,
+                                                 GLsizei instancecount)
+{
+    EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei instancecount = %d)",
+          mode, first, count, instancecount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArraysInstanced, context, modePacked, first, count, instancecount);
+        if (context->skipValidation() ||
+            ValidateDrawArraysInstanced(context, modePacked, first, count, instancecount))
+        {
+            context->drawArraysInstanced(modePacked, first, count, instancecount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum mode,
+                                                      GLint first,
+                                                      GLsizei count,
+                                                      GLsizei primcount)
+{
+    EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei primcount = %d)",
+          mode, first, count, primcount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArraysInstancedANGLE, context, modePacked, first, count, primcount);
+        if (context->skipValidation() ||
+            ValidateDrawArraysInstancedANGLE(context, modePacked, first, count, primcount))
+        {
+            context->drawArraysInstanced(modePacked, first, count, primcount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawArraysInstancedEXTContextANGLE(GLeglContext ctx,
+                                                    GLenum mode,
+                                                    GLint start,
+                                                    GLsizei count,
+                                                    GLsizei primcount)
+{
+    EVENT("(GLenum mode = 0x%X, GLint start = %d, GLsizei count = %d, GLsizei primcount = %d)",
+          mode, start, count, primcount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(DrawArraysInstancedEXT, context, modePacked, start, count, primcount);
+        if (context->skipValidation() ||
+            ValidateDrawArraysInstancedEXT(context, modePacked, start, count, primcount))
+        {
+            context->drawArraysInstanced(modePacked, start, count, primcount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawBuffersContextANGLE(GLeglContext ctx, GLsizei n, const GLenum *bufs)
+{
+    EVENT("(GLsizei n = %d, const GLenum *bufs = 0x%016" PRIxPTR ")", n, (uintptr_t)bufs);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawBuffers, context, n, bufs);
+        if (context->skipValidation() || ValidateDrawBuffers(context, n, bufs))
+        {
+            context->drawBuffers(n, bufs);
+        }
+    }
+}
+
+void GL_APIENTRY DrawBuffersEXTContextANGLE(GLeglContext ctx, GLsizei n, const GLenum *bufs)
+{
+    EVENT("(GLsizei n = %d, const GLenum *bufs = 0x%016" PRIxPTR ")", n, (uintptr_t)bufs);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawBuffersEXT, context, n, bufs);
+        if (context->skipValidation() || ValidateDrawBuffersEXT(context, n, bufs))
+        {
+            context->drawBuffers(n, bufs);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsContextANGLE(GLeglContext ctx,
+                                          GLenum mode,
+                                          GLsizei count,
+                                          GLenum type,
+                                          const void *indices)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = "
+        "0x%016" PRIxPTR ")",
+        mode, count, type, (uintptr_t)indices);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElements, context, modePacked, count, typePacked, indices);
+        if (context->skipValidation() ||
+            ValidateDrawElements(context, modePacked, count, typePacked, indices))
+        {
+            context->drawElements(modePacked, count, typePacked, indices);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsIndirectContextANGLE(GLeglContext ctx,
+                                                  GLenum mode,
+                                                  GLenum type,
+                                                  const void *indirect)
+{
+    EVENT("(GLenum mode = 0x%X, GLenum type = 0x%X, const void *indirect = 0x%016" PRIxPTR ")",
+          mode, type, (uintptr_t)indirect);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElementsIndirect, context, modePacked, typePacked, indirect);
+        if (context->skipValidation() ||
+            ValidateDrawElementsIndirect(context, modePacked, typePacked, indirect))
+        {
+            context->drawElementsIndirect(modePacked, typePacked, indirect);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsInstancedContextANGLE(GLeglContext ctx,
+                                                   GLenum mode,
+                                                   GLsizei count,
+                                                   GLenum type,
+                                                   const void *indices,
+                                                   GLsizei instancecount)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = "
+        "0x%016" PRIxPTR ", GLsizei instancecount = %d)",
+        mode, count, type, (uintptr_t)indices, instancecount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElementsInstanced, context, modePacked, count, typePacked, indices,
+                      instancecount);
+        if (context->skipValidation() ||
+            ValidateDrawElementsInstanced(context, modePacked, count, typePacked, indices,
+                                          instancecount))
+        {
+            context->drawElementsInstanced(modePacked, count, typePacked, indices, instancecount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum mode,
+                                                        GLsizei count,
+                                                        GLenum type,
+                                                        const void *indices,
+                                                        GLsizei primcount)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = "
+        "0x%016" PRIxPTR ", GLsizei primcount = %d)",
+        mode, count, type, (uintptr_t)indices, primcount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElementsInstancedANGLE, context, modePacked, count, typePacked, indices,
+                      primcount);
+        if (context->skipValidation() ||
+            ValidateDrawElementsInstancedANGLE(context, modePacked, count, typePacked, indices,
+                                               primcount))
+        {
+            context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawElementsInstancedEXTContextANGLE(GLeglContext ctx,
+                                                      GLenum mode,
+                                                      GLsizei count,
+                                                      GLenum type,
+                                                      const void *indices,
+                                                      GLsizei primcount)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const void *indices = "
+        "0x%016" PRIxPTR ", GLsizei primcount = %d)",
+        mode, count, type, (uintptr_t)indices, primcount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawElementsInstancedEXT, context, modePacked, count, typePacked, indices,
+                      primcount);
+        if (context->skipValidation() ||
+            ValidateDrawElementsInstancedEXT(context, modePacked, count, typePacked, indices,
+                                             primcount))
+        {
+            context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount);
+        }
+    }
+}
+
+void GL_APIENTRY DrawRangeElementsContextANGLE(GLeglContext ctx,
+                                               GLenum mode,
+                                               GLuint start,
+                                               GLuint end,
+                                               GLsizei count,
+                                               GLenum type,
+                                               const void *indices)
+{
+    EVENT(
+        "(GLenum mode = 0x%X, GLuint start = %u, GLuint end = %u, GLsizei count = %d, GLenum type "
+        "= 0x%X, const void *indices = 0x%016" PRIxPTR ")",
+        mode, start, end, count, type, (uintptr_t)indices);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(DrawRangeElements, context, modePacked, start, end, count, typePacked,
+                      indices);
+        if (context->skipValidation() ||
+            ValidateDrawRangeElements(context, modePacked, start, end, count, typePacked, indices))
+        {
+            context->drawRangeElements(modePacked, start, end, count, typePacked, indices);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexfOESContextANGLE(GLeglContext ctx,
+                                         GLfloat x,
+                                         GLfloat y,
+                                         GLfloat z,
+                                         GLfloat width,
+                                         GLfloat height)
+{
+    EVENT(
+        "(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat width = %f, GLfloat height = %f)",
+        x, y, z, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawTexfOES, context, x, y, z, width, height);
+        if (context->skipValidation() || ValidateDrawTexfOES(context, x, y, z, width, height))
+        {
+            context->drawTexf(x, y, z, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexfvOESContextANGLE(GLeglContext ctx, const GLfloat *coords)
+{
+    EVENT("(const GLfloat *coords = 0x%016" PRIxPTR ")", (uintptr_t)coords);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawTexfvOES, context, coords);
+        if (context->skipValidation() || ValidateDrawTexfvOES(context, coords))
+        {
+            context->drawTexfv(coords);
+        }
+    }
+}
+
+void GL_APIENTRY
+DrawTexiOESContextANGLE(GLeglContext ctx, GLint x, GLint y, GLint z, GLint width, GLint height)
+{
+    EVENT("(GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height = %d)", x, y,
+          z, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawTexiOES, context, x, y, z, width, height);
+        if (context->skipValidation() || ValidateDrawTexiOES(context, x, y, z, width, height))
+        {
+            context->drawTexi(x, y, z, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexivOESContextANGLE(GLeglContext ctx, const GLint *coords)
+{
+    EVENT("(const GLint *coords = 0x%016" PRIxPTR ")", (uintptr_t)coords);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawTexivOES, context, coords);
+        if (context->skipValidation() || ValidateDrawTexivOES(context, coords))
+        {
+            context->drawTexiv(coords);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexsOESContextANGLE(GLeglContext ctx,
+                                         GLshort x,
+                                         GLshort y,
+                                         GLshort z,
+                                         GLshort width,
+                                         GLshort height)
+{
+    EVENT(
+        "(GLshort x = %d, GLshort y = %d, GLshort z = %d, GLshort width = %d, GLshort height = %d)",
+        x, y, z, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawTexsOES, context, x, y, z, width, height);
+        if (context->skipValidation() || ValidateDrawTexsOES(context, x, y, z, width, height))
+        {
+            context->drawTexs(x, y, z, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexsvOESContextANGLE(GLeglContext ctx, const GLshort *coords)
+{
+    EVENT("(const GLshort *coords = 0x%016" PRIxPTR ")", (uintptr_t)coords);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawTexsvOES, context, coords);
+        if (context->skipValidation() || ValidateDrawTexsvOES(context, coords))
+        {
+            context->drawTexsv(coords);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexxOESContextANGLE(GLeglContext ctx,
+                                         GLfixed x,
+                                         GLfixed y,
+                                         GLfixed z,
+                                         GLfixed width,
+                                         GLfixed height)
+{
+    EVENT(
+        "(GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X, GLfixed width = 0x%X, GLfixed "
+        "height = 0x%X)",
+        x, y, z, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawTexxOES, context, x, y, z, width, height);
+        if (context->skipValidation() || ValidateDrawTexxOES(context, x, y, z, width, height))
+        {
+            context->drawTexx(x, y, z, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY DrawTexxvOESContextANGLE(GLeglContext ctx, const GLfixed *coords)
+{
+    EVENT("(const GLfixed *coords = 0x%016" PRIxPTR ")", (uintptr_t)coords);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DrawTexxvOES, context, coords);
+        if (context->skipValidation() || ValidateDrawTexxvOES(context, coords))
+        {
+            context->drawTexxv(coords);
+        }
+    }
+}
+
+void GL_APIENTRY EGLImageTargetRenderbufferStorageOESContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLeglImageOES image)
+{
+    EVENT("(GLenum target = 0x%X, GLeglImageOES image = 0x%016" PRIxPTR ")", target,
+          (uintptr_t)image);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(EGLImageTargetRenderbufferStorageOES, context, target, image);
+        if (context->skipValidation() ||
+            ValidateEGLImageTargetRenderbufferStorageOES(context, target, image))
+        {
+            context->eGLImageTargetRenderbufferStorage(target, image);
+        }
+    }
+}
+
+void GL_APIENTRY EGLImageTargetTexture2DOESContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLeglImageOES image)
+{
+    EVENT("(GLenum target = 0x%X, GLeglImageOES image = 0x%016" PRIxPTR ")", target,
+          (uintptr_t)image);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(EGLImageTargetTexture2DOES, context, targetPacked, image);
+        if (context->skipValidation() ||
+            ValidateEGLImageTargetTexture2DOES(context, targetPacked, image))
+        {
+            context->eGLImageTargetTexture2D(targetPacked, image);
+        }
+    }
+}
+
+void GL_APIENTRY EnableContextANGLE(GLeglContext ctx, GLenum cap)
+{
+    EVENT("(GLenum cap = 0x%X)", cap);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Enable, context, cap);
+        if (context->skipValidation() || ValidateEnable(context, cap))
+        {
+            context->enable(cap);
+        }
+    }
+}
+
+void GL_APIENTRY EnableClientStateContextANGLE(GLeglContext ctx, GLenum array)
+{
+    EVENT("(GLenum array = 0x%X)", array);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ClientVertexArrayType arrayPacked = FromGLenum<ClientVertexArrayType>(array);
+        ANGLE_CAPTURE(EnableClientState, context, arrayPacked);
+        if (context->skipValidation() || ValidateEnableClientState(context, arrayPacked))
+        {
+            context->enableClientState(arrayPacked);
+        }
+    }
+}
+
+void GL_APIENTRY EnableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index)
+{
+    EVENT("(GLuint index = %u)", index);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(EnableVertexAttribArray, context, index);
+        if (context->skipValidation() || ValidateEnableVertexAttribArray(context, index))
+        {
+            context->enableVertexAttribArray(index);
+        }
+    }
+}
+
+void GL_APIENTRY EndQueryContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(EndQuery, context, targetPacked);
+        if (context->skipValidation() || ValidateEndQuery(context, targetPacked))
+        {
+            context->endQuery(targetPacked);
+        }
+    }
+}
+
+void GL_APIENTRY EndQueryEXTContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(EndQueryEXT, context, targetPacked);
+        if (context->skipValidation() || ValidateEndQueryEXT(context, targetPacked))
+        {
+            context->endQuery(targetPacked);
+        }
+    }
+}
+
+void GL_APIENTRY EndTransformFeedbackContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(EndTransformFeedback, context);
+        if (context->skipValidation() || ValidateEndTransformFeedback(context))
+        {
+            context->endTransformFeedback();
+        }
+    }
+}
+
+GLsync GL_APIENTRY FenceSyncContextANGLE(GLeglContext ctx, GLenum condition, GLbitfield flags)
+{
+    EVENT("(GLenum condition = 0x%X, GLbitfield flags = 0x%X)", condition, flags);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FenceSync, context, condition, flags);
+        if (context->skipValidation() || ValidateFenceSync(context, condition, flags))
+        {
+            return context->fenceSync(condition, flags);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::FenceSync, GLsync>();
+}
+
+void GL_APIENTRY FinishContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Finish, context);
+        if (context->skipValidation() || ValidateFinish(context))
+        {
+            context->finish();
+        }
+    }
+}
+
+void GL_APIENTRY FinishFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
+{
+    EVENT("(GLuint fence = %u)", fence);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FinishFenceNV, context, fence);
+        if (context->skipValidation() || ValidateFinishFenceNV(context, fence))
+        {
+            context->finishFenceNV(fence);
+        }
+    }
+}
+
+void GL_APIENTRY FlushContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Flush, context);
+        if (context->skipValidation() || ValidateFlush(context))
+        {
+            context->flush();
+        }
+    }
+}
+
+void GL_APIENTRY FlushMappedBufferRangeContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLintptr offset,
+                                                    GLsizeiptr length)
+{
+    EVENT("(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr length = %llu)", target,
+          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(FlushMappedBufferRange, context, targetPacked, offset, length);
+        if (context->skipValidation() ||
+            ValidateFlushMappedBufferRange(context, targetPacked, offset, length))
+        {
+            context->flushMappedBufferRange(targetPacked, offset, length);
+        }
+    }
+}
+
+void GL_APIENTRY FlushMappedBufferRangeEXTContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLintptr offset,
+                                                       GLsizeiptr length)
+{
+    EVENT("(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr length = %llu)", target,
+          static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(FlushMappedBufferRangeEXT, context, targetPacked, offset, length);
+        if (context->skipValidation() ||
+            ValidateFlushMappedBufferRangeEXT(context, targetPacked, offset, length))
+        {
+            context->flushMappedBufferRange(targetPacked, offset, length);
+        }
+    }
+}
+
+void GL_APIENTRY FogfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Fogf, context, pname, param);
+        if (context->skipValidation() || ValidateFogf(context, pname, param))
+        {
+            context->fogf(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY FogfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Fogfv, context, pname, params);
+        if (context->skipValidation() || ValidateFogfv(context, pname, params))
+        {
+            context->fogfv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY FogxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfixed param = 0x%X)", pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Fogx, context, pname, param);
+        if (context->skipValidation() || ValidateFogx(context, pname, param))
+        {
+            context->fogx(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY FogxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *param)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfixed *param = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Fogxv, context, pname, param);
+        if (context->skipValidation() || ValidateFogxv(context, pname, param))
+        {
+            context->fogxv(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferParameteriContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum pname,
+                                                   GLint param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FramebufferParameteri, context, target, pname, param);
+        if (context->skipValidation() ||
+            ValidateFramebufferParameteri(context, target, pname, param))
+        {
+            context->framebufferParameteri(target, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferRenderbufferContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum attachment,
+                                                     GLenum renderbuffertarget,
+                                                     GLuint renderbuffer)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, GLuint "
+        "renderbuffer = %u)",
+        target, attachment, renderbuffertarget, renderbuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FramebufferRenderbuffer, context, target, attachment, renderbuffertarget,
+                      renderbuffer);
+        if (context->skipValidation() ||
+            ValidateFramebufferRenderbuffer(context, target, attachment, renderbuffertarget,
+                                            renderbuffer))
+        {
+            context->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferRenderbufferOESContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLenum attachment,
+                                                        GLenum renderbuffertarget,
+                                                        GLuint renderbuffer)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, GLuint "
+        "renderbuffer = %u)",
+        target, attachment, renderbuffertarget, renderbuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FramebufferRenderbufferOES, context, target, attachment, renderbuffertarget,
+                      renderbuffer);
+        if (context->skipValidation() ||
+            ValidateFramebufferRenderbufferOES(context, target, attachment, renderbuffertarget,
+                                               renderbuffer))
+        {
+            context->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTexture2DContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLenum attachment,
+                                                  GLenum textarget,
+                                                  GLuint texture,
+                                                  GLint level)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, GLuint texture "
+        "= %u, GLint level = %d)",
+        target, attachment, textarget, texture, level);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget textargetPacked = FromGLenum<TextureTarget>(textarget);
+        ANGLE_CAPTURE(FramebufferTexture2D, context, target, attachment, textargetPacked, texture,
+                      level);
+        if (context->skipValidation() ||
+            ValidateFramebufferTexture2D(context, target, attachment, textargetPacked, texture,
+                                         level))
+        {
+            context->framebufferTexture2D(target, attachment, textargetPacked, texture, level);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTexture2DOESContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum attachment,
+                                                     GLenum textarget,
+                                                     GLuint texture,
+                                                     GLint level)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, GLuint texture "
+        "= %u, GLint level = %d)",
+        target, attachment, textarget, texture, level);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget textargetPacked = FromGLenum<TextureTarget>(textarget);
+        ANGLE_CAPTURE(FramebufferTexture2DOES, context, target, attachment, textargetPacked,
+                      texture, level);
+        if (context->skipValidation() ||
+            ValidateFramebufferTexture2DOES(context, target, attachment, textargetPacked, texture,
+                                            level))
+        {
+            context->framebufferTexture2D(target, attachment, textargetPacked, texture, level);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTexture3DOESContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum attachment,
+                                                     GLenum textarget,
+                                                     GLuint texture,
+                                                     GLint level,
+                                                     GLint zoffset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, GLuint texture "
+        "= %u, GLint level = %d, GLint zoffset = %d)",
+        target, attachment, textarget, texture, level, zoffset);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget textargetPacked = FromGLenum<TextureTarget>(textarget);
+        ANGLE_CAPTURE(FramebufferTexture3DOES, context, target, attachment, textargetPacked,
+                      texture, level, zoffset);
+        if (context->skipValidation() ||
+            ValidateFramebufferTexture3DOES(context, target, attachment, textargetPacked, texture,
+                                            level, zoffset))
+        {
+            context->framebufferTexture3D(target, attachment, textargetPacked, texture, level,
+                                          zoffset);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTextureEXTContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum attachment,
+                                                   GLuint texture,
+                                                   GLint level)
+{
+    EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d)",
+          target, attachment, texture, level);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FramebufferTextureEXT, context, target, attachment, texture, level);
+        if (context->skipValidation() ||
+            ValidateFramebufferTextureEXT(context, target, attachment, texture, level))
+        {
+            context->framebufferTexture(target, attachment, texture, level);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTextureLayerContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum attachment,
+                                                     GLuint texture,
+                                                     GLint level,
+                                                     GLint layer)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d, "
+        "GLint layer = %d)",
+        target, attachment, texture, level, layer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FramebufferTextureLayer, context, target, attachment, texture, level, layer);
+        if (context->skipValidation() ||
+            ValidateFramebufferTextureLayer(context, target, attachment, texture, level, layer))
+        {
+            context->framebufferTextureLayer(target, attachment, texture, level, layer);
+        }
+    }
+}
+
+void GL_APIENTRY FramebufferTextureMultiviewOVRContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum attachment,
+                                                            GLuint texture,
+                                                            GLint level,
+                                                            GLint baseViewIndex,
+                                                            GLsizei numViews)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLuint texture = %u, GLint level = %d, "
+        "GLint baseViewIndex = %d, GLsizei numViews = %d)",
+        target, attachment, texture, level, baseViewIndex, numViews);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FramebufferTextureMultiviewOVR, context, target, attachment, texture, level,
+                      baseViewIndex, numViews);
+        if (context->skipValidation() ||
+            ValidateFramebufferTextureMultiviewOVR(context, target, attachment, texture, level,
+                                                   baseViewIndex, numViews))
+        {
+            context->framebufferTextureMultiview(target, attachment, texture, level, baseViewIndex,
+                                                 numViews);
+        }
+    }
+}
+
+void GL_APIENTRY FrontFaceContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(FrontFace, context, mode);
+        if (context->skipValidation() || ValidateFrontFace(context, mode))
+        {
+            context->frontFace(mode);
+        }
+    }
+}
+
+void GL_APIENTRY FrustumfContextANGLE(GLeglContext ctx,
+                                      GLfloat l,
+                                      GLfloat r,
+                                      GLfloat b,
+                                      GLfloat t,
+                                      GLfloat n,
+                                      GLfloat f)
+{
+    EVENT(
+        "(GLfloat l = %f, GLfloat r = %f, GLfloat b = %f, GLfloat t = %f, GLfloat n = %f, GLfloat "
+        "f = %f)",
+        l, r, b, t, n, f);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Frustumf, context, l, r, b, t, n, f);
+        if (context->skipValidation() || ValidateFrustumf(context, l, r, b, t, n, f))
+        {
+            context->frustumf(l, r, b, t, n, f);
+        }
+    }
+}
+
+void GL_APIENTRY FrustumxContextANGLE(GLeglContext ctx,
+                                      GLfixed l,
+                                      GLfixed r,
+                                      GLfixed b,
+                                      GLfixed t,
+                                      GLfixed n,
+                                      GLfixed f)
+{
+    EVENT(
+        "(GLfixed l = 0x%X, GLfixed r = 0x%X, GLfixed b = 0x%X, GLfixed t = 0x%X, GLfixed n = "
+        "0x%X, GLfixed f = 0x%X)",
+        l, r, b, t, n, f);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Frustumx, context, l, r, b, t, n, f);
+        if (context->skipValidation() || ValidateFrustumx(context, l, r, b, t, n, f))
+        {
+            context->frustumx(l, r, b, t, n, f);
+        }
+    }
+}
+
+void GL_APIENTRY GenBuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *buffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *buffers = 0x%016" PRIxPTR ")", n, (uintptr_t)buffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenBuffers, context, n, buffers);
+        if (context->skipValidation() || ValidateGenBuffers(context, n, buffers))
+        {
+            context->genBuffers(n, buffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenFencesNVContextANGLE(GLeglContext ctx, GLsizei n, GLuint *fences)
+{
+    EVENT("(GLsizei n = %d, GLuint *fences = 0x%016" PRIxPTR ")", n, (uintptr_t)fences);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenFencesNV, context, n, fences);
+        if (context->skipValidation() || ValidateGenFencesNV(context, n, fences))
+        {
+            context->genFencesNV(n, fences);
+        }
+    }
+}
+
+void GL_APIENTRY GenFramebuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *framebuffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *framebuffers = 0x%016" PRIxPTR ")", n, (uintptr_t)framebuffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenFramebuffers, context, n, framebuffers);
+        if (context->skipValidation() || ValidateGenFramebuffers(context, n, framebuffers))
+        {
+            context->genFramebuffers(n, framebuffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenFramebuffersOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *framebuffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *framebuffers = 0x%016" PRIxPTR ")", n, (uintptr_t)framebuffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenFramebuffersOES, context, n, framebuffers);
+        if (context->skipValidation() || ValidateGenFramebuffersOES(context, n, framebuffers))
+        {
+            context->genFramebuffers(n, framebuffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenProgramPipelinesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *pipelines)
+{
+    EVENT("(GLsizei n = %d, GLuint *pipelines = 0x%016" PRIxPTR ")", n, (uintptr_t)pipelines);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenProgramPipelines, context, n, pipelines);
+        if (context->skipValidation() || ValidateGenProgramPipelines(context, n, pipelines))
+        {
+            context->genProgramPipelines(n, pipelines);
+        }
+    }
+}
+
+void GL_APIENTRY GenQueriesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenQueries, context, n, ids);
+        if (context->skipValidation() || ValidateGenQueries(context, n, ids))
+        {
+            context->genQueries(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY GenQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenQueriesEXT, context, n, ids);
+        if (context->skipValidation() || ValidateGenQueriesEXT(context, n, ids))
+        {
+            context->genQueries(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY GenRenderbuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *renderbuffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *renderbuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)renderbuffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenRenderbuffers, context, n, renderbuffers);
+        if (context->skipValidation() || ValidateGenRenderbuffers(context, n, renderbuffers))
+        {
+            context->genRenderbuffers(n, renderbuffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenRenderbuffersOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *renderbuffers)
+{
+    EVENT("(GLsizei n = %d, GLuint *renderbuffers = 0x%016" PRIxPTR ")", n,
+          (uintptr_t)renderbuffers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenRenderbuffersOES, context, n, renderbuffers);
+        if (context->skipValidation() || ValidateGenRenderbuffersOES(context, n, renderbuffers))
+        {
+            context->genRenderbuffers(n, renderbuffers);
+        }
+    }
+}
+
+void GL_APIENTRY GenSamplersContextANGLE(GLeglContext ctx, GLsizei count, GLuint *samplers)
+{
+    EVENT("(GLsizei count = %d, GLuint *samplers = 0x%016" PRIxPTR ")", count, (uintptr_t)samplers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenSamplers, context, count, samplers);
+        if (context->skipValidation() || ValidateGenSamplers(context, count, samplers))
+        {
+            context->genSamplers(count, samplers);
+        }
+    }
+}
+
+void GL_APIENTRY GenSemaphoresEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *semaphores)
+{
+    EVENT("(GLsizei n = %d, GLuint *semaphores = 0x%016" PRIxPTR ")", n, (uintptr_t)semaphores);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenSemaphoresEXT, context, n, semaphores);
+        if (context->skipValidation() || ValidateGenSemaphoresEXT(context, n, semaphores))
+        {
+            context->genSemaphores(n, semaphores);
+        }
+    }
+}
+
+void GL_APIENTRY GenTexturesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *textures)
+{
+    EVENT("(GLsizei n = %d, GLuint *textures = 0x%016" PRIxPTR ")", n, (uintptr_t)textures);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenTextures, context, n, textures);
+        if (context->skipValidation() || ValidateGenTextures(context, n, textures))
+        {
+            context->genTextures(n, textures);
+        }
+    }
+}
+
+void GL_APIENTRY GenTransformFeedbacksContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
+{
+    EVENT("(GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR ")", n, (uintptr_t)ids);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenTransformFeedbacks, context, n, ids);
+        if (context->skipValidation() || ValidateGenTransformFeedbacks(context, n, ids))
+        {
+            context->genTransformFeedbacks(n, ids);
+        }
+    }
+}
+
+void GL_APIENTRY GenVertexArraysContextANGLE(GLeglContext ctx, GLsizei n, GLuint *arrays)
+{
+    EVENT("(GLsizei n = %d, GLuint *arrays = 0x%016" PRIxPTR ")", n, (uintptr_t)arrays);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenVertexArrays, context, n, arrays);
+        if (context->skipValidation() || ValidateGenVertexArrays(context, n, arrays))
+        {
+            context->genVertexArrays(n, arrays);
+        }
+    }
+}
+
+void GL_APIENTRY GenVertexArraysOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *arrays)
+{
+    EVENT("(GLsizei n = %d, GLuint *arrays = 0x%016" PRIxPTR ")", n, (uintptr_t)arrays);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenVertexArraysOES, context, n, arrays);
+        if (context->skipValidation() || ValidateGenVertexArraysOES(context, n, arrays))
+        {
+            context->genVertexArrays(n, arrays);
+        }
+    }
+}
+
+void GL_APIENTRY GenerateMipmapContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GenerateMipmap, context, targetPacked);
+        if (context->skipValidation() || ValidateGenerateMipmap(context, targetPacked))
+        {
+            context->generateMipmap(targetPacked);
+        }
+    }
+}
+
+void GL_APIENTRY GenerateMipmapOESContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GenerateMipmapOES, context, targetPacked);
+        if (context->skipValidation() || ValidateGenerateMipmapOES(context, targetPacked))
+        {
+            context->generateMipmap(targetPacked);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveAttribContextANGLE(GLeglContext ctx,
+                                             GLuint program,
+                                             GLuint index,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLint *size,
+                                             GLenum *type,
+                                             GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei *length = "
+        "0x%016" PRIxPTR ", GLint *size = 0x%016" PRIxPTR ", GLenum *type = 0x%016" PRIxPTR
+        ", GLchar *name = 0x%016" PRIxPTR ")",
+        program, index, bufSize, (uintptr_t)length, (uintptr_t)size, (uintptr_t)type,
+        (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetActiveAttrib, context, program, index, bufSize, length, size, type, name);
+        if (context->skipValidation() ||
+            ValidateGetActiveAttrib(context, program, index, bufSize, length, size, type, name))
+        {
+            context->getActiveAttrib(program, index, bufSize, length, size, type, name);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLuint index,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLint *size,
+                                              GLenum *type,
+                                              GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei *length = "
+        "0x%016" PRIxPTR ", GLint *size = 0x%016" PRIxPTR ", GLenum *type = 0x%016" PRIxPTR
+        ", GLchar *name = 0x%016" PRIxPTR ")",
+        program, index, bufSize, (uintptr_t)length, (uintptr_t)size, (uintptr_t)type,
+        (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetActiveUniform, context, program, index, bufSize, length, size, type, name);
+        if (context->skipValidation() ||
+            ValidateGetActiveUniform(context, program, index, bufSize, length, size, type, name))
+        {
+            context->getActiveUniform(program, index, bufSize, length, size, type, name);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformBlockNameContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLuint uniformBlockIndex,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLchar *uniformBlockName)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint uniformBlockIndex = %u, GLsizei bufSize = %d, GLsizei "
+        "*length = 0x%016" PRIxPTR ", GLchar *uniformBlockName = 0x%016" PRIxPTR ")",
+        program, uniformBlockIndex, bufSize, (uintptr_t)length, (uintptr_t)uniformBlockName);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetActiveUniformBlockName, context, program, uniformBlockIndex, bufSize,
+                      length, uniformBlockName);
+        if (context->skipValidation() ||
+            ValidateGetActiveUniformBlockName(context, program, uniformBlockIndex, bufSize, length,
+                                              uniformBlockName))
+        {
+            context->getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length,
+                                               uniformBlockName);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformBlockivContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLuint uniformBlockIndex,
+                                                     GLenum pname,
+                                                     GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = 0x%X, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        program, uniformBlockIndex, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetActiveUniformBlockiv, context, program, uniformBlockIndex, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetActiveUniformBlockiv(context, program, uniformBlockIndex, pname, params))
+        {
+            context->getActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformsivContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLsizei uniformCount,
+                                                 const GLuint *uniformIndices,
+                                                 GLenum pname,
+                                                 GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLsizei uniformCount = %d, const GLuint *uniformIndices = "
+        "0x%016" PRIxPTR ", GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")",
+        program, uniformCount, (uintptr_t)uniformIndices, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetActiveUniformsiv, context, program, uniformCount, uniformIndices, pname,
+                      params);
+        if (context->skipValidation() || ValidateGetActiveUniformsiv(context, program, uniformCount,
+                                                                     uniformIndices, pname, params))
+        {
+            context->getActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetAttachedShadersContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLsizei maxCount,
+                                                GLsizei *count,
+                                                GLuint *shaders)
+{
+    EVENT("(GLuint program = %u, GLsizei maxCount = %d, GLsizei *count = 0x%016" PRIxPTR
+          ", GLuint *shaders = 0x%016" PRIxPTR ")",
+          program, maxCount, (uintptr_t)count, (uintptr_t)shaders);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetAttachedShaders, context, program, maxCount, count, shaders);
+        if (context->skipValidation() ||
+            ValidateGetAttachedShaders(context, program, maxCount, count, shaders))
+        {
+            context->getAttachedShaders(program, maxCount, count, shaders);
+        }
+    }
+}
+
+GLint GL_APIENTRY GetAttribLocationContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetAttribLocation, context, program, name);
+        if (context->skipValidation() || ValidateGetAttribLocation(context, program, name))
+        {
+            return context->getAttribLocation(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetAttribLocation, GLint>();
+}
+
+void GL_APIENTRY GetBooleani_vContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLuint index,
+                                           GLboolean *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLboolean *data = 0x%016" PRIxPTR ")", target,
+          index, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetBooleani_v, context, target, index, data);
+        if (context->skipValidation() || ValidateGetBooleani_v(context, target, index, data))
+        {
+            context->getBooleani_v(target, index, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetBooleanvContextANGLE(GLeglContext ctx, GLenum pname, GLboolean *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLboolean *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetBooleanv, context, pname, data);
+        if (context->skipValidation() || ValidateGetBooleanv(context, pname, data))
+        {
+            context->getBooleanv(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferParameteri64vContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLenum pname,
+                                                    GLint64 *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint64 *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferParameteri64v, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetBufferParameteri64v(context, targetPacked, pname, params))
+        {
+            context->getBufferParameteri64v(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferParameterivContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLenum pname,
+                                                  GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferParameteriv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetBufferParameteriv(context, targetPacked, pname, params))
+        {
+            context->getBufferParameteriv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferPointervContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLenum pname,
+                                               void **params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, void **params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferPointerv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetBufferPointerv(context, targetPacked, pname, params))
+        {
+            context->getBufferPointerv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferPointervOESContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLenum pname,
+                                                  void **params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, void **params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferPointervOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetBufferPointervOES(context, targetPacked, pname, params))
+        {
+            context->getBufferPointerv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetClipPlanefContextANGLE(GLeglContext ctx, GLenum plane, GLfloat *equation)
+{
+    EVENT("(GLenum plane = 0x%X, GLfloat *equation = 0x%016" PRIxPTR ")", plane,
+          (uintptr_t)equation);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetClipPlanef, context, plane, equation);
+        if (context->skipValidation() || ValidateGetClipPlanef(context, plane, equation))
+        {
+            context->getClipPlanef(plane, equation);
+        }
+    }
+}
+
+void GL_APIENTRY GetClipPlanexContextANGLE(GLeglContext ctx, GLenum plane, GLfixed *equation)
+{
+    EVENT("(GLenum plane = 0x%X, GLfixed *equation = 0x%016" PRIxPTR ")", plane,
+          (uintptr_t)equation);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetClipPlanex, context, plane, equation);
+        if (context->skipValidation() || ValidateGetClipPlanex(context, plane, equation))
+        {
+            context->getClipPlanex(plane, equation);
+        }
+    }
+}
+
+GLuint GL_APIENTRY GetDebugMessageLogKHRContextANGLE(GLeglContext ctx,
+                                                     GLuint count,
+                                                     GLsizei bufSize,
+                                                     GLenum *sources,
+                                                     GLenum *types,
+                                                     GLuint *ids,
+                                                     GLenum *severities,
+                                                     GLsizei *lengths,
+                                                     GLchar *messageLog)
+{
+    EVENT("(GLuint count = %u, GLsizei bufSize = %d, GLenum *sources = 0x%016" PRIxPTR
+          ", GLenum *types = 0x%016" PRIxPTR ", GLuint *ids = 0x%016" PRIxPTR
+          ", GLenum *severities = 0x%016" PRIxPTR ", GLsizei *lengths = 0x%016" PRIxPTR
+          ", GLchar *messageLog = 0x%016" PRIxPTR ")",
+          count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids,
+          (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetDebugMessageLogKHR, context, count, bufSize, sources, types, ids,
+                      severities, lengths, messageLog);
+        if (context->skipValidation() ||
+            ValidateGetDebugMessageLogKHR(context, count, bufSize, sources, types, ids, severities,
+                                          lengths, messageLog))
+        {
+            return context->getDebugMessageLog(count, bufSize, sources, types, ids, severities,
+                                               lengths, messageLog);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetDebugMessageLogKHR, GLuint>();
+}
+
+GLenum GL_APIENTRY GetErrorContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetError, context);
+        if (context->skipValidation() || ValidateGetError(context))
+        {
+            return context->getError();
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetError, GLenum>();
+}
+
+void GL_APIENTRY GetFenceivNVContextANGLE(GLeglContext ctx,
+                                          GLuint fence,
+                                          GLenum pname,
+                                          GLint *params)
+{
+    EVENT("(GLuint fence = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", fence,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFenceivNV, context, fence, pname, params);
+        if (context->skipValidation() || ValidateGetFenceivNV(context, fence, pname, params))
+        {
+            context->getFenceivNV(fence, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFixedvContextANGLE(GLeglContext ctx, GLenum pname, GLfixed *params)
+{
+    EVENT("(GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")", pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFixedv, context, pname, params);
+        if (context->skipValidation() || ValidateGetFixedv(context, pname, params))
+        {
+            context->getFixedv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFloatvContextANGLE(GLeglContext ctx, GLenum pname, GLfloat *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLfloat *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFloatv, context, pname, data);
+        if (context->skipValidation() || ValidateGetFloatv(context, pname, data))
+        {
+            context->getFloatv(pname, data);
+        }
+    }
+}
+
+GLint GL_APIENTRY GetFragDataIndexEXTContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFragDataIndexEXT, context, program, name);
+        if (context->skipValidation() || ValidateGetFragDataIndexEXT(context, program, name))
+        {
+            return context->getFragDataIndex(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetFragDataIndexEXT, GLint>();
+}
+
+GLint GL_APIENTRY GetFragDataLocationContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFragDataLocation, context, program, name);
+        if (context->skipValidation() || ValidateGetFragDataLocation(context, program, name))
+        {
+            return context->getFragDataLocation(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetFragDataLocation, GLint>();
+}
+
+void GL_APIENTRY GetFramebufferAttachmentParameterivContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLenum attachment,
+                                                                 GLenum pname,
+                                                                 GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        target, attachment, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFramebufferAttachmentParameteriv, context, target, attachment, pname,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetFramebufferAttachmentParameteriv(context, target, attachment, pname, params))
+        {
+            context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferAttachmentParameterivOESContextANGLE(GLeglContext ctx,
+                                                                    GLenum target,
+                                                                    GLenum attachment,
+                                                                    GLenum pname,
+                                                                    GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        target, attachment, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFramebufferAttachmentParameterivOES, context, target, attachment, pname,
+                      params);
+        if (context->skipValidation() || ValidateGetFramebufferAttachmentParameterivOES(
+                                             context, target, attachment, pname, params))
+        {
+            context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferParameterivContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLenum pname,
+                                                       GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFramebufferParameteriv, context, target, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetFramebufferParameteriv(context, target, pname, params))
+        {
+            context->getFramebufferParameteriv(target, pname, params);
+        }
+    }
+}
+
+GLenum GL_APIENTRY GetGraphicsResetStatusEXTContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetGraphicsResetStatusEXT, context);
+        if (context->skipValidation() || ValidateGetGraphicsResetStatusEXT(context))
+        {
+            return context->getGraphicsResetStatus();
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetGraphicsResetStatusEXT, GLenum>();
+}
+
+void GL_APIENTRY GetInteger64i_vContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLuint index,
+                                             GLint64 *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLint64 *data = 0x%016" PRIxPTR ")", target,
+          index, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetInteger64i_v, context, target, index, data);
+        if (context->skipValidation() || ValidateGetInteger64i_v(context, target, index, data))
+        {
+            context->getInteger64i_v(target, index, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetInteger64vContextANGLE(GLeglContext ctx, GLenum pname, GLint64 *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLint64 *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetInteger64v, context, pname, data);
+        if (context->skipValidation() || ValidateGetInteger64v(context, pname, data))
+        {
+            context->getInteger64v(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetIntegeri_vContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLuint index,
+                                           GLint *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLint *data = 0x%016" PRIxPTR ")", target,
+          index, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetIntegeri_v, context, target, index, data);
+        if (context->skipValidation() || ValidateGetIntegeri_v(context, target, index, data))
+        {
+            context->getIntegeri_v(target, index, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetIntegervContextANGLE(GLeglContext ctx, GLenum pname, GLint *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLint *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetIntegerv, context, pname, data);
+        if (context->skipValidation() || ValidateGetIntegerv(context, pname, data))
+        {
+            context->getIntegerv(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetInternalformativContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLenum internalformat,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLenum pname = 0x%X, GLsizei bufSize "
+        "= %d, GLint *params = 0x%016" PRIxPTR ")",
+        target, internalformat, pname, bufSize, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetInternalformativ, context, target, internalformat, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateGetInternalformativ(context, target, internalformat, pname, bufSize, params))
+        {
+            context->getInternalformativ(target, internalformat, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetLightfvContextANGLE(GLeglContext ctx,
+                                        GLenum light,
+                                        GLenum pname,
+                                        GLfloat *params)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")", light,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(GetLightfv, context, light, pnamePacked, params);
+        if (context->skipValidation() || ValidateGetLightfv(context, light, pnamePacked, params))
+        {
+            context->getLightfv(light, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetLightxvContextANGLE(GLeglContext ctx,
+                                        GLenum light,
+                                        GLenum pname,
+                                        GLfixed *params)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")", light,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(GetLightxv, context, light, pnamePacked, params);
+        if (context->skipValidation() || ValidateGetLightxv(context, light, pnamePacked, params))
+        {
+            context->getLightxv(light, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetMaterialfvContextANGLE(GLeglContext ctx,
+                                           GLenum face,
+                                           GLenum pname,
+                                           GLfloat *params)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")", face,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(GetMaterialfv, context, face, pnamePacked, params);
+        if (context->skipValidation() || ValidateGetMaterialfv(context, face, pnamePacked, params))
+        {
+            context->getMaterialfv(face, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetMaterialxvContextANGLE(GLeglContext ctx,
+                                           GLenum face,
+                                           GLenum pname,
+                                           GLfixed *params)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")", face,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(GetMaterialxv, context, face, pnamePacked, params);
+        if (context->skipValidation() || ValidateGetMaterialxv(context, face, pnamePacked, params))
+        {
+            context->getMaterialxv(face, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetMemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
+                                                           GLuint memoryObject,
+                                                           GLenum pname,
+                                                           GLint *params)
+{
+    EVENT("(GLuint memoryObject = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")",
+          memoryObject, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetMemoryObjectParameterivEXT, context, memoryObject, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetMemoryObjectParameterivEXT(context, memoryObject, pname, params))
+        {
+            context->getMemoryObjectParameteriv(memoryObject, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetMultisamplefvContextANGLE(GLeglContext ctx,
+                                              GLenum pname,
+                                              GLuint index,
+                                              GLfloat *val)
+{
+    EVENT("(GLenum pname = 0x%X, GLuint index = %u, GLfloat *val = 0x%016" PRIxPTR ")", pname,
+          index, (uintptr_t)val);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetMultisamplefv, context, pname, index, val);
+        if (context->skipValidation() || ValidateGetMultisamplefv(context, pname, index, val))
+        {
+            context->getMultisamplefv(pname, index, val);
+        }
+    }
+}
+
+void GL_APIENTRY GetObjectLabelKHRContextANGLE(GLeglContext ctx,
+                                               GLenum identifier,
+                                               GLuint name,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLchar *label)
+{
+    EVENT(
+        "(GLenum identifier = 0x%X, GLuint name = %u, GLsizei bufSize = %d, GLsizei *length = "
+        "0x%016" PRIxPTR ", GLchar *label = 0x%016" PRIxPTR ")",
+        identifier, name, bufSize, (uintptr_t)length, (uintptr_t)label);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetObjectLabelKHR, context, identifier, name, bufSize, length, label);
+        if (context->skipValidation() ||
+            ValidateGetObjectLabelKHR(context, identifier, name, bufSize, length, label))
+        {
+            context->getObjectLabel(identifier, name, bufSize, length, label);
+        }
+    }
+}
+
+void GL_APIENTRY GetObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
+                                                  const void *ptr,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLchar *label)
+{
+    EVENT("(const void *ptr = 0x%016" PRIxPTR
+          ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *label = 0x%016" PRIxPTR ")",
+          (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetObjectPtrLabelKHR, context, ptr, bufSize, length, label);
+        if (context->skipValidation() ||
+            ValidateGetObjectPtrLabelKHR(context, ptr, bufSize, length, label))
+        {
+            context->getObjectPtrLabel(ptr, bufSize, length, label);
+        }
+    }
+}
+
+void GL_APIENTRY GetPointervContextANGLE(GLeglContext ctx, GLenum pname, void **params)
+{
+    EVENT("(GLenum pname = 0x%X, void **params = 0x%016" PRIxPTR ")", pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetPointerv, context, pname, params);
+        if (context->skipValidation() || ValidateGetPointerv(context, pname, params))
+        {
+            context->getPointerv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetPointervKHRContextANGLE(GLeglContext ctx, GLenum pname, void **params)
+{
+    EVENT("(GLenum pname = 0x%X, void **params = 0x%016" PRIxPTR ")", pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetPointervKHR, context, pname, params);
+        if (context->skipValidation() || ValidateGetPointervKHR(context, pname, params))
+        {
+            context->getPointerv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramBinaryContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLenum *binaryFormat,
+                                              void *binary)
+{
+    EVENT("(GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR ")",
+          program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat, (uintptr_t)binary);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramBinary, context, program, bufSize, length, binaryFormat, binary);
+        if (context->skipValidation() ||
+            ValidateGetProgramBinary(context, program, bufSize, length, binaryFormat, binary))
+        {
+            context->getProgramBinary(program, bufSize, length, binaryFormat, binary);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramBinaryOESContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLenum *binaryFormat,
+                                                 void *binary)
+{
+    EVENT("(GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR ")",
+          program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat, (uintptr_t)binary);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramBinaryOES, context, program, bufSize, length, binaryFormat, binary);
+        if (context->skipValidation() ||
+            ValidateGetProgramBinaryOES(context, program, bufSize, length, binaryFormat, binary))
+        {
+            context->getProgramBinary(program, bufSize, length, binaryFormat, binary);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramInfoLogContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLchar *infoLog)
+{
+    EVENT("(GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *infoLog = 0x%016" PRIxPTR ")",
+          program, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramInfoLog, context, program, bufSize, length, infoLog);
+        if (context->skipValidation() ||
+            ValidateGetProgramInfoLog(context, program, bufSize, length, infoLog))
+        {
+            context->getProgramInfoLog(program, bufSize, length, infoLog);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramInterfaceivContextANGLE(GLeglContext ctx,
+                                                   GLuint program,
+                                                   GLenum programInterface,
+                                                   GLenum pname,
+                                                   GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, GLenum pname = 0x%X, GLint *params "
+        "= 0x%016" PRIxPTR ")",
+        program, programInterface, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramInterfaceiv, context, program, programInterface, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramInterfaceiv(context, program, programInterface, pname, params))
+        {
+            context->getProgramInterfaceiv(program, programInterface, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramPipelineInfoLogContextANGLE(GLeglContext ctx,
+                                                       GLuint pipeline,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLchar *infoLog)
+{
+    EVENT("(GLuint pipeline = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *infoLog = 0x%016" PRIxPTR ")",
+          pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramPipelineInfoLog, context, pipeline, bufSize, length, infoLog);
+        if (context->skipValidation() ||
+            ValidateGetProgramPipelineInfoLog(context, pipeline, bufSize, length, infoLog))
+        {
+            context->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramPipelineivContextANGLE(GLeglContext ctx,
+                                                  GLuint pipeline,
+                                                  GLenum pname,
+                                                  GLint *params)
+{
+    EVENT("(GLuint pipeline = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")",
+          pipeline, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramPipelineiv, context, pipeline, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramPipelineiv(context, pipeline, pname, params))
+        {
+            context->getProgramPipelineiv(pipeline, pname, params);
+        }
+    }
+}
+
+GLuint GL_APIENTRY GetProgramResourceIndexContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLenum programInterface,
+                                                       const GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, const GLchar *name = 0x%016" PRIxPTR
+        ")",
+        program, programInterface, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramResourceIndex, context, program, programInterface, name);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceIndex(context, program, programInterface, name))
+        {
+            return context->getProgramResourceIndex(program, programInterface, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>();
+}
+
+GLint GL_APIENTRY GetProgramResourceLocationContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLenum programInterface,
+                                                         const GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, const GLchar *name = 0x%016" PRIxPTR
+        ")",
+        program, programInterface, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramResourceLocation, context, program, programInterface, name);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceLocation(context, program, programInterface, name))
+        {
+            return context->getProgramResourceLocation(program, programInterface, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>();
+}
+
+GLint GL_APIENTRY GetProgramResourceLocationIndexEXTContextANGLE(GLeglContext ctx,
+                                                                 GLuint program,
+                                                                 GLenum programInterface,
+                                                                 const GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, const GLchar *name = 0x%016" PRIxPTR
+        ")",
+        program, programInterface, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramResourceLocationIndexEXT, context, program, programInterface, name);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceLocationIndexEXT(context, program, programInterface, name))
+        {
+            return context->getProgramResourceLocationIndex(program, programInterface, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetProgramResourceLocationIndexEXT, GLint>();
+}
+
+void GL_APIENTRY GetProgramResourceNameContextANGLE(GLeglContext ctx,
+                                                    GLuint program,
+                                                    GLenum programInterface,
+                                                    GLuint index,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, GLuint index = %u, GLsizei bufSize "
+        "= %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR ")",
+        program, programInterface, index, bufSize, (uintptr_t)length, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramResourceName, context, program, programInterface, index, bufSize,
+                      length, name);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceName(context, program, programInterface, index, bufSize,
+                                           length, name))
+        {
+            context->getProgramResourceName(program, programInterface, index, bufSize, length,
+                                            name);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramResourceivContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  GLenum programInterface,
+                                                  GLuint index,
+                                                  GLsizei propCount,
+                                                  const GLenum *props,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, GLuint index = %u, GLsizei "
+        "propCount = %d, const GLenum *props = 0x%016" PRIxPTR
+        ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+        ", GLint *params = 0x%016" PRIxPTR ")",
+        program, programInterface, index, propCount, (uintptr_t)props, bufSize, (uintptr_t)length,
+        (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramResourceiv, context, program, programInterface, index, propCount,
+                      props, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceiv(context, program, programInterface, index, propCount,
+                                         props, bufSize, length, params))
+        {
+            context->getProgramResourceiv(program, programInterface, index, propCount, props,
+                                          bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramivContextANGLE(GLeglContext ctx,
+                                          GLuint program,
+                                          GLenum pname,
+                                          GLint *params)
+{
+    EVENT("(GLuint program = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", program,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramiv, context, program, pname, params);
+        if (context->skipValidation() || ValidateGetProgramiv(context, program, pname, params))
+        {
+            context->getProgramiv(program, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjecti64vEXTContextANGLE(GLeglContext ctx,
+                                                   GLuint id,
+                                                   GLenum pname,
+                                                   GLint64 *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLint64 *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjecti64vEXT, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjecti64vEXT(context, id, pname, params))
+        {
+            context->getQueryObjecti64v(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectivEXTContextANGLE(GLeglContext ctx,
+                                                 GLuint id,
+                                                 GLenum pname,
+                                                 GLint *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjectivEXT, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjectivEXT(context, id, pname, params))
+        {
+            context->getQueryObjectiv(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectui64vEXTContextANGLE(GLeglContext ctx,
+                                                    GLuint id,
+                                                    GLenum pname,
+                                                    GLuint64 *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLuint64 *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjectui64vEXT, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjectui64vEXT(context, id, pname, params))
+        {
+            context->getQueryObjectui64v(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectuivContextANGLE(GLeglContext ctx,
+                                               GLuint id,
+                                               GLenum pname,
+                                               GLuint *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjectuiv, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjectuiv(context, id, pname, params))
+        {
+            context->getQueryObjectuiv(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectuivEXTContextANGLE(GLeglContext ctx,
+                                                  GLuint id,
+                                                  GLenum pname,
+                                                  GLuint *params)
+{
+    EVENT("(GLuint id = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", id, pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjectuivEXT, context, id, pname, params);
+        if (context->skipValidation() || ValidateGetQueryObjectuivEXT(context, id, pname, params))
+        {
+            context->getQueryObjectuiv(id, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryivContextANGLE(GLeglContext ctx,
+                                        GLenum target,
+                                        GLenum pname,
+                                        GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(GetQueryiv, context, targetPacked, pname, params);
+        if (context->skipValidation() || ValidateGetQueryiv(context, targetPacked, pname, params))
+        {
+            context->getQueryiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryivEXTContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLenum pname,
+                                           GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(GetQueryivEXT, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryivEXT(context, targetPacked, pname, params))
+        {
+            context->getQueryiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetRenderbufferParameterivContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetRenderbufferParameteriv, context, target, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetRenderbufferParameteriv(context, target, pname, params))
+        {
+            context->getRenderbufferParameteriv(target, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetRenderbufferParameterivOESContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLenum pname,
+                                                           GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetRenderbufferParameterivOES, context, target, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetRenderbufferParameterivOES(context, target, pname, params))
+        {
+            context->getRenderbufferParameteriv(target, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterIivOESContextANGLE(GLeglContext ctx,
+                                                       GLuint sampler,
+                                                       GLenum pname,
+                                                       GLint *params)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", sampler,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSamplerParameterIivOES, context, sampler, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSamplerParameterIivOES(context, sampler, pname, params))
+        {
+            context->getSamplerParameterIiv(sampler, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                        GLuint sampler,
+                                                        GLenum pname,
+                                                        GLuint *params)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", sampler,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSamplerParameterIuivOES, context, sampler, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSamplerParameterIuivOES(context, sampler, pname, params))
+        {
+            context->getSamplerParameterIuiv(sampler, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterfvContextANGLE(GLeglContext ctx,
+                                                   GLuint sampler,
+                                                   GLenum pname,
+                                                   GLfloat *params)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSamplerParameterfv, context, sampler, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSamplerParameterfv(context, sampler, pname, params))
+        {
+            context->getSamplerParameterfv(sampler, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterivContextANGLE(GLeglContext ctx,
+                                                   GLuint sampler,
+                                                   GLenum pname,
+                                                   GLint *params)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", sampler,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSamplerParameteriv, context, sampler, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSamplerParameteriv(context, sampler, pname, params))
+        {
+            context->getSamplerParameteriv(sampler, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
+                                                           GLuint semaphore,
+                                                           GLenum pname,
+                                                           GLuint64 *params)
+{
+    EVENT("(GLuint semaphore = %u, GLenum pname = 0x%X, GLuint64 *params = 0x%016" PRIxPTR ")",
+          semaphore, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSemaphoreParameterui64vEXT, context, semaphore, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetSemaphoreParameterui64vEXT(context, semaphore, pname, params))
+        {
+            context->getSemaphoreParameterui64v(semaphore, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderInfoLogContextANGLE(GLeglContext ctx,
+                                              GLuint shader,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLchar *infoLog)
+{
+    EVENT("(GLuint shader = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *infoLog = 0x%016" PRIxPTR ")",
+          shader, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetShaderInfoLog, context, shader, bufSize, length, infoLog);
+        if (context->skipValidation() ||
+            ValidateGetShaderInfoLog(context, shader, bufSize, length, infoLog))
+        {
+            context->getShaderInfoLog(shader, bufSize, length, infoLog);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderPrecisionFormatContextANGLE(GLeglContext ctx,
+                                                      GLenum shadertype,
+                                                      GLenum precisiontype,
+                                                      GLint *range,
+                                                      GLint *precision)
+{
+    EVENT("(GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint *range = 0x%016" PRIxPTR
+          ", GLint *precision = 0x%016" PRIxPTR ")",
+          shadertype, precisiontype, (uintptr_t)range, (uintptr_t)precision);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetShaderPrecisionFormat, context, shadertype, precisiontype, range,
+                      precision);
+        if (context->skipValidation() ||
+            ValidateGetShaderPrecisionFormat(context, shadertype, precisiontype, range, precision))
+        {
+            context->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderSourceContextANGLE(GLeglContext ctx,
+                                             GLuint shader,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLchar *source)
+{
+    EVENT("(GLuint shader = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *source = 0x%016" PRIxPTR ")",
+          shader, bufSize, (uintptr_t)length, (uintptr_t)source);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetShaderSource, context, shader, bufSize, length, source);
+        if (context->skipValidation() ||
+            ValidateGetShaderSource(context, shader, bufSize, length, source))
+        {
+            context->getShaderSource(shader, bufSize, length, source);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderivContextANGLE(GLeglContext ctx,
+                                         GLuint shader,
+                                         GLenum pname,
+                                         GLint *params)
+{
+    EVENT("(GLuint shader = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", shader,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetShaderiv, context, shader, pname, params);
+        if (context->skipValidation() || ValidateGetShaderiv(context, shader, pname, params))
+        {
+            context->getShaderiv(shader, pname, params);
+        }
+    }
+}
+
+const GLubyte *GL_APIENTRY GetStringContextANGLE(GLeglContext ctx, GLenum name)
+{
+    EVENT("(GLenum name = 0x%X)", name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetString, context, name);
+        if (context->skipValidation() || ValidateGetString(context, name))
+        {
+            return context->getString(name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetString, const GLubyte *>();
+}
+
+const GLubyte *GL_APIENTRY GetStringiContextANGLE(GLeglContext ctx, GLenum name, GLuint index)
+{
+    EVENT("(GLenum name = 0x%X, GLuint index = %u)", name, index);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetStringi, context, name, index);
+        if (context->skipValidation() || ValidateGetStringi(context, name, index))
+        {
+            return context->getStringi(name, index);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetStringi, const GLubyte *>();
+}
+
+void GL_APIENTRY GetSyncivContextANGLE(GLeglContext ctx,
+                                       GLsync sync,
+                                       GLenum pname,
+                                       GLsizei bufSize,
+                                       GLsizei *length,
+                                       GLint *values)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR
+          ", GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLint *values = 0x%016" PRIxPTR ")",
+          (uintptr_t)sync, pname, bufSize, (uintptr_t)length, (uintptr_t)values);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSynciv, context, sync, pname, bufSize, length, values);
+        if (context->skipValidation() ||
+            ValidateGetSynciv(context, sync, pname, bufSize, length, values))
+        {
+            context->getSynciv(sync, pname, bufSize, length, values);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexEnvfvContextANGLE(GLeglContext ctx,
+                                         GLenum target,
+                                         GLenum pname,
+                                         GLfloat *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(GetTexEnvfv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateGetTexEnvfv(context, targetPacked, pnamePacked, params))
+        {
+            context->getTexEnvfv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexEnvivContextANGLE(GLeglContext ctx,
+                                         GLenum target,
+                                         GLenum pname,
+                                         GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(GetTexEnviv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateGetTexEnviv(context, targetPacked, pnamePacked, params))
+        {
+            context->getTexEnviv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexEnvxvContextANGLE(GLeglContext ctx,
+                                         GLenum target,
+                                         GLenum pname,
+                                         GLfixed *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(GetTexEnvxv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateGetTexEnvxv(context, targetPacked, pnamePacked, params))
+        {
+            context->getTexEnvxv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexGenfvOESContextANGLE(GLeglContext ctx,
+                                            GLenum coord,
+                                            GLenum pname,
+                                            GLfloat *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")", coord,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetTexGenfvOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateGetTexGenfvOES(context, coord, pname, params))
+        {
+            context->getTexGenfv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexGenivOESContextANGLE(GLeglContext ctx,
+                                            GLenum coord,
+                                            GLenum pname,
+                                            GLint *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", coord,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetTexGenivOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateGetTexGenivOES(context, coord, pname, params))
+        {
+            context->getTexGeniv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexGenxvOESContextANGLE(GLeglContext ctx,
+                                            GLenum coord,
+                                            GLenum pname,
+                                            GLfixed *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")", coord,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetTexGenxvOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateGetTexGenxvOES(context, coord, pname, params))
+        {
+            context->getTexGenxv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterfvContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLint level,
+                                                    GLenum pname,
+                                                    GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLfloat *params = "
+        "0x%016" PRIxPTR ")",
+        target, level, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterfv, context, targetPacked, level, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterfv(context, targetPacked, level, pname, params))
+        {
+            context->getTexLevelParameterfv(targetPacked, level, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterivContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLint level,
+                                                    GLenum pname,
+                                                    GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        target, level, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameteriv, context, targetPacked, level, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameteriv(context, targetPacked, level, pname, params))
+        {
+            context->getTexLevelParameteriv(targetPacked, level, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterIivOESContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum pname,
+                                                   GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterIivOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameterIivOES(context, targetPacked, pname, params))
+        {
+            context->getTexParameterIiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLenum pname,
+                                                    GLuint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterIuivOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameterIuivOES(context, targetPacked, pname, params))
+        {
+            context->getTexParameterIuiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterfvContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLenum pname,
+                                               GLfloat *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterfv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameterfv(context, targetPacked, pname, params))
+        {
+            context->getTexParameterfv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterivContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLenum pname,
+                                               GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", target,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameteriv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameteriv(context, targetPacked, pname, params))
+        {
+            context->getTexParameteriv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterxvContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLenum pname,
+                                               GLfixed *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfixed *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterxv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexParameterxv(context, targetPacked, pname, params))
+        {
+            context->getTexParameterxv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTransformFeedbackVaryingContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLuint index,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLsizei *size,
+                                                         GLenum *type,
+                                                         GLchar *name)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint index = %u, GLsizei bufSize = %d, GLsizei *length = "
+        "0x%016" PRIxPTR ", GLsizei *size = 0x%016" PRIxPTR ", GLenum *type = 0x%016" PRIxPTR
+        ", GLchar *name = 0x%016" PRIxPTR ")",
+        program, index, bufSize, (uintptr_t)length, (uintptr_t)size, (uintptr_t)type,
+        (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetTransformFeedbackVarying, context, program, index, bufSize, length, size,
+                      type, name);
+        if (context->skipValidation() ||
+            ValidateGetTransformFeedbackVarying(context, program, index, bufSize, length, size,
+                                                type, name))
+        {
+            context->getTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+        }
+    }
+}
+
+void GL_APIENTRY GetTranslatedShaderSourceANGLEContextANGLE(GLeglContext ctx,
+                                                            GLuint shader,
+                                                            GLsizei bufsize,
+                                                            GLsizei *length,
+                                                            GLchar *source)
+{
+    EVENT("(GLuint shader = %u, GLsizei bufsize = %d, GLsizei *length = 0x%016" PRIxPTR
+          ", GLchar *source = 0x%016" PRIxPTR ")",
+          shader, bufsize, (uintptr_t)length, (uintptr_t)source);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetTranslatedShaderSourceANGLE, context, shader, bufsize, length, source);
+        if (context->skipValidation() ||
+            ValidateGetTranslatedShaderSourceANGLE(context, shader, bufsize, length, source))
+        {
+            context->getTranslatedShaderSource(shader, bufsize, length, source);
+        }
+    }
+}
+
+GLuint GL_APIENTRY GetUniformBlockIndexContextANGLE(GLeglContext ctx,
+                                                    GLuint program,
+                                                    const GLchar *uniformBlockName)
+{
+    EVENT("(GLuint program = %u, const GLchar *uniformBlockName = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)uniformBlockName);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformBlockIndex, context, program, uniformBlockName);
+        if (context->skipValidation() ||
+            ValidateGetUniformBlockIndex(context, program, uniformBlockName))
+        {
+            return context->getUniformBlockIndex(program, uniformBlockName);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetUniformBlockIndex, GLuint>();
+}
+
+void GL_APIENTRY GetUniformIndicesContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLsizei uniformCount,
+                                               const GLchar *const *uniformNames,
+                                               GLuint *uniformIndices)
+{
+    EVENT(
+        "(GLuint program = %u, GLsizei uniformCount = %d, const GLchar *const*uniformNames = "
+        "0x%016" PRIxPTR ", GLuint *uniformIndices = 0x%016" PRIxPTR ")",
+        program, uniformCount, (uintptr_t)uniformNames, (uintptr_t)uniformIndices);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformIndices, context, program, uniformCount, uniformNames,
+                      uniformIndices);
+        if (context->skipValidation() ||
+            ValidateGetUniformIndices(context, program, uniformCount, uniformNames, uniformIndices))
+        {
+            context->getUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+        }
+    }
+}
+
+GLint GL_APIENTRY GetUniformLocationContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%016" PRIxPTR ")", program,
+          (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformLocation, context, program, name);
+        if (context->skipValidation() || ValidateGetUniformLocation(context, program, name))
+        {
+            return context->getUniformLocation(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetUniformLocation, GLint>();
+}
+
+void GL_APIENTRY GetUniformfvContextANGLE(GLeglContext ctx,
+                                          GLuint program,
+                                          GLint location,
+                                          GLfloat *params)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLfloat *params = 0x%016" PRIxPTR ")",
+          program, location, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformfv, context, program, location, params);
+        if (context->skipValidation() || ValidateGetUniformfv(context, program, location, params))
+        {
+            context->getUniformfv(program, location, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformivContextANGLE(GLeglContext ctx,
+                                          GLuint program,
+                                          GLint location,
+                                          GLint *params)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLint *params = 0x%016" PRIxPTR ")", program,
+          location, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformiv, context, program, location, params);
+        if (context->skipValidation() || ValidateGetUniformiv(context, program, location, params))
+        {
+            context->getUniformiv(program, location, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformuivContextANGLE(GLeglContext ctx,
+                                           GLuint program,
+                                           GLint location,
+                                           GLuint *params)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLuint *params = 0x%016" PRIxPTR ")", program,
+          location, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformuiv, context, program, location, params);
+        if (context->skipValidation() || ValidateGetUniformuiv(context, program, location, params))
+        {
+            context->getUniformuiv(program, location, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUnsignedBytevEXTContextANGLE(GLeglContext ctx, GLenum pname, GLubyte *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLubyte *data = 0x%016" PRIxPTR ")", pname, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUnsignedBytevEXT, context, pname, data);
+        if (context->skipValidation() || ValidateGetUnsignedBytevEXT(context, pname, data))
+        {
+            context->getUnsignedBytev(pname, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetUnsignedBytei_vEXTContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLuint index,
+                                                   GLubyte *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLubyte *data = 0x%016" PRIxPTR ")", target,
+          index, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUnsignedBytei_vEXT, context, target, index, data);
+        if (context->skipValidation() ||
+            ValidateGetUnsignedBytei_vEXT(context, target, index, data))
+        {
+            context->getUnsignedBytei_v(target, index, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribIivContextANGLE(GLeglContext ctx,
+                                                GLuint index,
+                                                GLenum pname,
+                                                GLint *params)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribIiv, context, index, pname, params);
+        if (context->skipValidation() || ValidateGetVertexAttribIiv(context, index, pname, params))
+        {
+            context->getVertexAttribIiv(index, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribIuivContextANGLE(GLeglContext ctx,
+                                                 GLuint index,
+                                                 GLenum pname,
+                                                 GLuint *params)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLuint *params = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribIuiv, context, index, pname, params);
+        if (context->skipValidation() || ValidateGetVertexAttribIuiv(context, index, pname, params))
+        {
+            context->getVertexAttribIuiv(index, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribPointervContextANGLE(GLeglContext ctx,
+                                                     GLuint index,
+                                                     GLenum pname,
+                                                     void **pointer)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, void **pointer = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribPointerv, context, index, pname, pointer);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribPointerv(context, index, pname, pointer))
+        {
+            context->getVertexAttribPointerv(index, pname, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribfvContextANGLE(GLeglContext ctx,
+                                               GLuint index,
+                                               GLenum pname,
+                                               GLfloat *params)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLfloat *params = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribfv, context, index, pname, params);
+        if (context->skipValidation() || ValidateGetVertexAttribfv(context, index, pname, params))
+        {
+            context->getVertexAttribfv(index, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribivContextANGLE(GLeglContext ctx,
+                                               GLuint index,
+                                               GLenum pname,
+                                               GLint *params)
+{
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, GLint *params = 0x%016" PRIxPTR ")", index,
+          pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribiv, context, index, pname, params);
+        if (context->skipValidation() || ValidateGetVertexAttribiv(context, index, pname, params))
+        {
+            context->getVertexAttribiv(index, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformfvEXTContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLsizei bufSize,
+                                              GLfloat *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLfloat *params = "
+        "0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetnUniformfvEXT, context, program, location, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformfvEXT(context, program, location, bufSize, params))
+        {
+            context->getnUniformfv(program, location, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformivEXTContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLsizei bufSize,
+                                              GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLint *params = "
+        "0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetnUniformivEXT, context, program, location, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformivEXT(context, program, location, bufSize, params))
+        {
+            context->getnUniformiv(program, location, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY HintContextANGLE(GLeglContext ctx, GLenum target, GLenum mode)
+{
+    EVENT("(GLenum target = 0x%X, GLenum mode = 0x%X)", target, mode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Hint, context, target, mode);
+        if (context->skipValidation() || ValidateHint(context, target, mode))
+        {
+            context->hint(target, mode);
+        }
+    }
+}
+
+void GL_APIENTRY ImportMemoryFdEXTContextANGLE(GLeglContext ctx,
+                                               GLuint memory,
+                                               GLuint64 size,
+                                               GLenum handleType,
+                                               GLint fd)
+{
+    EVENT("(GLuint memory = %u, GLuint64 size = %llu, GLenum handleType = 0x%X, GLint fd = %d)",
+          memory, static_cast<unsigned long long>(size), handleType, fd);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        HandleType handleTypePacked = FromGLenum<HandleType>(handleType);
+        ANGLE_CAPTURE(ImportMemoryFdEXT, context, memory, size, handleTypePacked, fd);
+        if (context->skipValidation() ||
+            ValidateImportMemoryFdEXT(context, memory, size, handleTypePacked, fd))
+        {
+            context->importMemoryFd(memory, size, handleTypePacked, fd);
+        }
+    }
+}
+
+void GL_APIENTRY ImportSemaphoreFdEXTContextANGLE(GLeglContext ctx,
+                                                  GLuint semaphore,
+                                                  GLenum handleType,
+                                                  GLint fd)
+{
+    EVENT("(GLuint semaphore = %u, GLenum handleType = 0x%X, GLint fd = %d)", semaphore, handleType,
+          fd);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        HandleType handleTypePacked = FromGLenum<HandleType>(handleType);
+        ANGLE_CAPTURE(ImportSemaphoreFdEXT, context, semaphore, handleTypePacked, fd);
+        if (context->skipValidation() ||
+            ValidateImportSemaphoreFdEXT(context, semaphore, handleTypePacked, fd))
+        {
+            context->importSemaphoreFd(semaphore, handleTypePacked, fd);
+        }
+    }
+}
+
+void GL_APIENTRY InsertEventMarkerEXTContextANGLE(GLeglContext ctx,
+                                                  GLsizei length,
+                                                  const GLchar *marker)
+{
+    // Don't run an EVENT() macro on the EXT_debug_marker entry points.
+    // It can interfere with the debug events being set by the caller.
+    // EVENT("(GLsizei length = %d, const GLchar *marker = 0x%016" PRIxPTR ")", length,
+    // (uintptr_t)marker);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(InsertEventMarkerEXT, context, length, marker);
+        if (context->skipValidation() || ValidateInsertEventMarkerEXT(context, length, marker))
+        {
+            context->insertEventMarker(length, marker);
+        }
+    }
+}
+
+void GL_APIENTRY InvalidateFramebufferContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLsizei numAttachments,
+                                                   const GLenum *attachments)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum *attachments = "
+        "0x%016" PRIxPTR ")",
+        target, numAttachments, (uintptr_t)attachments);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(InvalidateFramebuffer, context, target, numAttachments, attachments);
+        if (context->skipValidation() ||
+            ValidateInvalidateFramebuffer(context, target, numAttachments, attachments))
+        {
+            context->invalidateFramebuffer(target, numAttachments, attachments);
+        }
+    }
+}
+
+void GL_APIENTRY InvalidateSubFramebufferContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLsizei numAttachments,
+                                                      const GLenum *attachments,
+                                                      GLint x,
+                                                      GLint y,
+                                                      GLsizei width,
+                                                      GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei numAttachments = %d, const GLenum *attachments = "
+        "0x%016" PRIxPTR ", GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
+        target, numAttachments, (uintptr_t)attachments, x, y, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(InvalidateSubFramebuffer, context, target, numAttachments, attachments, x, y,
+                      width, height);
+        if (context->skipValidation() ||
+            ValidateInvalidateSubFramebuffer(context, target, numAttachments, attachments, x, y,
+                                             width, height))
+        {
+            context->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width,
+                                              height);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsBufferContextANGLE(GLeglContext ctx, GLuint buffer)
+{
+    EVENT("(GLuint buffer = %u)", buffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsBuffer, context, buffer);
+        if (context->skipValidation() || ValidateIsBuffer(context, buffer))
+        {
+            return context->isBuffer(buffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsBuffer, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsEnabledContextANGLE(GLeglContext ctx, GLenum cap)
+{
+    EVENT("(GLenum cap = 0x%X)", cap);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsEnabled, context, cap);
+        if (context->skipValidation() || ValidateIsEnabled(context, cap))
+        {
+            return context->isEnabled(cap);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsEnabled, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
+{
+    EVENT("(GLuint fence = %u)", fence);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsFenceNV, context, fence);
+        if (context->skipValidation() || ValidateIsFenceNV(context, fence))
+        {
+            return context->isFenceNV(fence);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsFenceNV, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsFramebufferContextANGLE(GLeglContext ctx, GLuint framebuffer)
+{
+    EVENT("(GLuint framebuffer = %u)", framebuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsFramebuffer, context, framebuffer);
+        if (context->skipValidation() || ValidateIsFramebuffer(context, framebuffer))
+        {
+            return context->isFramebuffer(framebuffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsFramebuffer, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsFramebufferOESContextANGLE(GLeglContext ctx, GLuint framebuffer)
+{
+    EVENT("(GLuint framebuffer = %u)", framebuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsFramebufferOES, context, framebuffer);
+        if (context->skipValidation() || ValidateIsFramebufferOES(context, framebuffer))
+        {
+            return context->isFramebuffer(framebuffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsFramebufferOES, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsMemoryObjectEXTContextANGLE(GLeglContext ctx, GLuint memoryObject)
+{
+    EVENT("(GLuint memoryObject = %u)", memoryObject);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsMemoryObjectEXT, context, memoryObject);
+        if (context->skipValidation() || ValidateIsMemoryObjectEXT(context, memoryObject))
+        {
+            return context->isMemoryObject(memoryObject);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsMemoryObjectEXT, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsProgram, context, program);
+        if (context->skipValidation() || ValidateIsProgram(context, program))
+        {
+            return context->isProgram(program);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsProgram, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
+{
+    EVENT("(GLuint pipeline = %u)", pipeline);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsProgramPipeline, context, pipeline);
+        if (context->skipValidation() || ValidateIsProgramPipeline(context, pipeline))
+        {
+            return context->isProgramPipeline(pipeline);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsQueryContextANGLE(GLeglContext ctx, GLuint id)
+{
+    EVENT("(GLuint id = %u)", id);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsQuery, context, id);
+        if (context->skipValidation() || ValidateIsQuery(context, id))
+        {
+            return context->isQuery(id);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsQuery, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsQueryEXTContextANGLE(GLeglContext ctx, GLuint id)
+{
+    EVENT("(GLuint id = %u)", id);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsQueryEXT, context, id);
+        if (context->skipValidation() || ValidateIsQueryEXT(context, id))
+        {
+            return context->isQuery(id);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsQueryEXT, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsRenderbufferContextANGLE(GLeglContext ctx, GLuint renderbuffer)
+{
+    EVENT("(GLuint renderbuffer = %u)", renderbuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsRenderbuffer, context, renderbuffer);
+        if (context->skipValidation() || ValidateIsRenderbuffer(context, renderbuffer))
+        {
+            return context->isRenderbuffer(renderbuffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsRenderbuffer, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsRenderbufferOESContextANGLE(GLeglContext ctx, GLuint renderbuffer)
+{
+    EVENT("(GLuint renderbuffer = %u)", renderbuffer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsRenderbufferOES, context, renderbuffer);
+        if (context->skipValidation() || ValidateIsRenderbufferOES(context, renderbuffer))
+        {
+            return context->isRenderbuffer(renderbuffer);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsRenderbufferOES, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsSemaphoreEXTContextANGLE(GLeglContext ctx, GLuint semaphore)
+{
+    EVENT("(GLuint semaphore = %u)", semaphore);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsSemaphoreEXT, context, semaphore);
+        if (context->skipValidation() || ValidateIsSemaphoreEXT(context, semaphore))
+        {
+            return context->isSemaphore(semaphore);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsSemaphoreEXT, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsSamplerContextANGLE(GLeglContext ctx, GLuint sampler)
+{
+    EVENT("(GLuint sampler = %u)", sampler);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsSampler, context, sampler);
+        if (context->skipValidation() || ValidateIsSampler(context, sampler))
+        {
+            return context->isSampler(sampler);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsSampler, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsShaderContextANGLE(GLeglContext ctx, GLuint shader)
+{
+    EVENT("(GLuint shader = %u)", shader);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsShader, context, shader);
+        if (context->skipValidation() || ValidateIsShader(context, shader))
+        {
+            return context->isShader(shader);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsShader, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsSyncContextANGLE(GLeglContext ctx, GLsync sync)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR ")", (uintptr_t)sync);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsSync, context, sync);
+        if (context->skipValidation() || ValidateIsSync(context, sync))
+        {
+            return context->isSync(sync);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsSync, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsTextureContextANGLE(GLeglContext ctx, GLuint texture)
+{
+    EVENT("(GLuint texture = %u)", texture);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsTexture, context, texture);
+        if (context->skipValidation() || ValidateIsTexture(context, texture))
+        {
+            return context->isTexture(texture);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsTexture, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsTransformFeedbackContextANGLE(GLeglContext ctx, GLuint id)
+{
+    EVENT("(GLuint id = %u)", id);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsTransformFeedback, context, id);
+        if (context->skipValidation() || ValidateIsTransformFeedback(context, id))
+        {
+            return context->isTransformFeedback(id);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsVertexArrayContextANGLE(GLeglContext ctx, GLuint array)
+{
+    EVENT("(GLuint array = %u)", array);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsVertexArray, context, array);
+        if (context->skipValidation() || ValidateIsVertexArray(context, array))
+        {
+            return context->isVertexArray(array);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsVertexArray, GLboolean>();
+}
+
+GLboolean GL_APIENTRY IsVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array)
+{
+    EVENT("(GLuint array = %u)", array);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsVertexArrayOES, context, array);
+        if (context->skipValidation() || ValidateIsVertexArrayOES(context, array))
+        {
+            return context->isVertexArray(array);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsVertexArrayOES, GLboolean>();
+}
+
+void GL_APIENTRY LightModelfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LightModelf, context, pname, param);
+        if (context->skipValidation() || ValidateLightModelf(context, pname, param))
+        {
+            context->lightModelf(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY LightModelfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LightModelfv, context, pname, params);
+        if (context->skipValidation() || ValidateLightModelfv(context, pname, params))
+        {
+            context->lightModelfv(pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY LightModelxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfixed param = 0x%X)", pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LightModelx, context, pname, param);
+        if (context->skipValidation() || ValidateLightModelx(context, pname, param))
+        {
+            context->lightModelx(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY LightModelxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *param)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfixed *param = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LightModelxv, context, pname, param);
+        if (context->skipValidation() || ValidateLightModelxv(context, pname, param))
+        {
+            context->lightModelxv(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY LightfContextANGLE(GLeglContext ctx, GLenum light, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", light, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(Lightf, context, light, pnamePacked, param);
+        if (context->skipValidation() || ValidateLightf(context, light, pnamePacked, param))
+        {
+            context->lightf(light, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY LightfvContextANGLE(GLeglContext ctx,
+                                     GLenum light,
+                                     GLenum pname,
+                                     const GLfloat *params)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          light, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(Lightfv, context, light, pnamePacked, params);
+        if (context->skipValidation() || ValidateLightfv(context, light, pnamePacked, params))
+        {
+            context->lightfv(light, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY LightxContextANGLE(GLeglContext ctx, GLenum light, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", light, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(Lightx, context, light, pnamePacked, param);
+        if (context->skipValidation() || ValidateLightx(context, light, pnamePacked, param))
+        {
+            context->lightx(light, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY LightxvContextANGLE(GLeglContext ctx,
+                                     GLenum light,
+                                     GLenum pname,
+                                     const GLfixed *params)
+{
+    EVENT("(GLenum light = 0x%X, GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")",
+          light, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        LightParameter pnamePacked = FromGLenum<LightParameter>(pname);
+        ANGLE_CAPTURE(Lightxv, context, light, pnamePacked, params);
+        if (context->skipValidation() || ValidateLightxv(context, light, pnamePacked, params))
+        {
+            context->lightxv(light, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY LineWidthContextANGLE(GLeglContext ctx, GLfloat width)
+{
+    EVENT("(GLfloat width = %f)", width);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LineWidth, context, width);
+        if (context->skipValidation() || ValidateLineWidth(context, width))
+        {
+            context->lineWidth(width);
+        }
+    }
+}
+
+void GL_APIENTRY LineWidthxContextANGLE(GLeglContext ctx, GLfixed width)
+{
+    EVENT("(GLfixed width = 0x%X)", width);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LineWidthx, context, width);
+        if (context->skipValidation() || ValidateLineWidthx(context, width))
+        {
+            context->lineWidthx(width);
+        }
+    }
+}
+
+void GL_APIENTRY LinkProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LinkProgram, context, program);
+        if (context->skipValidation() || ValidateLinkProgram(context, program))
+        {
+            context->linkProgram(program);
+        }
+    }
+}
+
+void GL_APIENTRY LoadIdentityContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LoadIdentity, context);
+        if (context->skipValidation() || ValidateLoadIdentity(context))
+        {
+            context->loadIdentity();
+        }
+    }
+}
+
+void GL_APIENTRY LoadMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m)
+{
+    EVENT("(const GLfloat *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LoadMatrixf, context, m);
+        if (context->skipValidation() || ValidateLoadMatrixf(context, m))
+        {
+            context->loadMatrixf(m);
+        }
+    }
+}
+
+void GL_APIENTRY LoadMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m)
+{
+    EVENT("(const GLfixed *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LoadMatrixx, context, m);
+        if (context->skipValidation() || ValidateLoadMatrixx(context, m))
+        {
+            context->loadMatrixx(m);
+        }
+    }
+}
+
+void GL_APIENTRY LoadPaletteFromModelViewMatrixOESContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(LoadPaletteFromModelViewMatrixOES, context);
+        if (context->skipValidation() || ValidateLoadPaletteFromModelViewMatrixOES(context))
+        {
+            context->loadPaletteFromModelViewMatrix();
+        }
+    }
+}
+
+void GL_APIENTRY LogicOpContextANGLE(GLeglContext ctx, GLenum opcode)
+{
+    EVENT("(GLenum opcode = 0x%X)", opcode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        LogicalOperation opcodePacked = FromGLenum<LogicalOperation>(opcode);
+        ANGLE_CAPTURE(LogicOp, context, opcodePacked);
+        if (context->skipValidation() || ValidateLogicOp(context, opcodePacked))
+        {
+            context->logicOp(opcodePacked);
+        }
+    }
+}
+
+void *GL_APIENTRY MapBufferOESContextANGLE(GLeglContext ctx, GLenum target, GLenum access)
+{
+    EVENT("(GLenum target = 0x%X, GLenum access = 0x%X)", target, access);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(MapBufferOES, context, targetPacked, access);
+        if (context->skipValidation() || ValidateMapBufferOES(context, targetPacked, access))
+        {
+            return context->mapBuffer(targetPacked, access);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::MapBufferOES, void *>();
+}
+
+void *GL_APIENTRY MapBufferRangeContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLintptr offset,
+                                             GLsizeiptr length,
+                                             GLbitfield access)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr length = %llu, GLbitfield "
+        "access = 0x%X)",
+        target, static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
+        access);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(MapBufferRange, context, targetPacked, offset, length, access);
+        if (context->skipValidation() ||
+            ValidateMapBufferRange(context, targetPacked, offset, length, access))
+        {
+            return context->mapBufferRange(targetPacked, offset, length, access);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::MapBufferRange, void *>();
+}
+
+void *GL_APIENTRY MapBufferRangeEXTContextANGLE(GLeglContext ctx,
+                                                GLenum target,
+                                                GLintptr offset,
+                                                GLsizeiptr length,
+                                                GLbitfield access)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLintptr offset = %llu, GLsizeiptr length = %llu, GLbitfield "
+        "access = 0x%X)",
+        target, static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length),
+        access);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(MapBufferRangeEXT, context, targetPacked, offset, length, access);
+        if (context->skipValidation() ||
+            ValidateMapBufferRangeEXT(context, targetPacked, offset, length, access))
+        {
+            return context->mapBufferRange(targetPacked, offset, length, access);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::MapBufferRangeEXT, void *>();
+}
+
+void GL_APIENTRY MaterialfContextANGLE(GLeglContext ctx, GLenum face, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", face, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(Materialf, context, face, pnamePacked, param);
+        if (context->skipValidation() || ValidateMaterialf(context, face, pnamePacked, param))
+        {
+            context->materialf(face, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY MaterialfvContextANGLE(GLeglContext ctx,
+                                        GLenum face,
+                                        GLenum pname,
+                                        const GLfloat *params)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          face, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(Materialfv, context, face, pnamePacked, params);
+        if (context->skipValidation() || ValidateMaterialfv(context, face, pnamePacked, params))
+        {
+            context->materialfv(face, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY MaterialxContextANGLE(GLeglContext ctx, GLenum face, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", face, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(Materialx, context, face, pnamePacked, param);
+        if (context->skipValidation() || ValidateMaterialx(context, face, pnamePacked, param))
+        {
+            context->materialx(face, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY MaterialxvContextANGLE(GLeglContext ctx,
+                                        GLenum face,
+                                        GLenum pname,
+                                        const GLfixed *param)
+{
+    EVENT("(GLenum face = 0x%X, GLenum pname = 0x%X, const GLfixed *param = 0x%016" PRIxPTR ")",
+          face, pname, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        MaterialParameter pnamePacked = FromGLenum<MaterialParameter>(pname);
+        ANGLE_CAPTURE(Materialxv, context, face, pnamePacked, param);
+        if (context->skipValidation() || ValidateMaterialxv(context, face, pnamePacked, param))
+        {
+            context->materialxv(face, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY MatrixIndexPointerOESContextANGLE(GLeglContext ctx,
+                                                   GLint size,
+                                                   GLenum type,
+                                                   GLsizei stride,
+                                                   const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MatrixIndexPointerOES, context, size, type, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateMatrixIndexPointerOES(context, size, type, stride, pointer))
+        {
+            context->matrixIndexPointer(size, type, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY MatrixModeContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        MatrixType modePacked = FromGLenum<MatrixType>(mode);
+        ANGLE_CAPTURE(MatrixMode, context, modePacked);
+        if (context->skipValidation() || ValidateMatrixMode(context, modePacked))
+        {
+            context->matrixMode(modePacked);
+        }
+    }
+}
+
+void GL_APIENTRY MaxShaderCompilerThreadsKHRContextANGLE(GLeglContext ctx, GLuint count)
+{
+    EVENT("(GLuint count = %u)", count);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MaxShaderCompilerThreadsKHR, context, count);
+        if (context->skipValidation() || ValidateMaxShaderCompilerThreadsKHR(context, count))
+        {
+            context->maxShaderCompilerThreads(count);
+        }
+    }
+}
+
+void GL_APIENTRY MemoryBarrierContextANGLE(GLeglContext ctx, GLbitfield barriers)
+{
+    EVENT("(GLbitfield barriers = 0x%X)", barriers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MemoryBarrier, context, barriers);
+        if (context->skipValidation() || ValidateMemoryBarrier(context, barriers))
+        {
+            context->memoryBarrier(barriers);
+        }
+    }
+}
+
+void GL_APIENTRY MemoryBarrierByRegionContextANGLE(GLeglContext ctx, GLbitfield barriers)
+{
+    EVENT("(GLbitfield barriers = 0x%X)", barriers);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MemoryBarrierByRegion, context, barriers);
+        if (context->skipValidation() || ValidateMemoryBarrierByRegion(context, barriers))
+        {
+            context->memoryBarrierByRegion(barriers);
+        }
+    }
+}
+
+void GL_APIENTRY MemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
+                                                        GLuint memoryObject,
+                                                        GLenum pname,
+                                                        const GLint *params)
+{
+    EVENT("(GLuint memoryObject = %u, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR
+          ")",
+          memoryObject, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MemoryObjectParameterivEXT, context, memoryObject, pname, params);
+        if (context->skipValidation() ||
+            ValidateMemoryObjectParameterivEXT(context, memoryObject, pname, params))
+        {
+            context->memoryObjectParameteriv(memoryObject, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY MultMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m)
+{
+    EVENT("(const GLfloat *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MultMatrixf, context, m);
+        if (context->skipValidation() || ValidateMultMatrixf(context, m))
+        {
+            context->multMatrixf(m);
+        }
+    }
+}
+
+void GL_APIENTRY MultMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m)
+{
+    EVENT("(const GLfixed *m = 0x%016" PRIxPTR ")", (uintptr_t)m);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MultMatrixx, context, m);
+        if (context->skipValidation() || ValidateMultMatrixx(context, m))
+        {
+            context->multMatrixx(m);
+        }
+    }
+}
+
+void GL_APIENTRY MultiTexCoord4fContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLfloat s,
+                                             GLfloat t,
+                                             GLfloat r,
+                                             GLfloat q)
+{
+    EVENT("(GLenum target = 0x%X, GLfloat s = %f, GLfloat t = %f, GLfloat r = %f, GLfloat q = %f)",
+          target, s, t, r, q);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MultiTexCoord4f, context, target, s, t, r, q);
+        if (context->skipValidation() || ValidateMultiTexCoord4f(context, target, s, t, r, q))
+        {
+            context->multiTexCoord4f(target, s, t, r, q);
+        }
+    }
+}
+
+void GL_APIENTRY MultiTexCoord4xContextANGLE(GLeglContext ctx,
+                                             GLenum texture,
+                                             GLfixed s,
+                                             GLfixed t,
+                                             GLfixed r,
+                                             GLfixed q)
+{
+    EVENT(
+        "(GLenum texture = 0x%X, GLfixed s = 0x%X, GLfixed t = 0x%X, GLfixed r = 0x%X, GLfixed q = "
+        "0x%X)",
+        texture, s, t, r, q);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MultiTexCoord4x, context, texture, s, t, r, q);
+        if (context->skipValidation() || ValidateMultiTexCoord4x(context, texture, s, t, r, q))
+        {
+            context->multiTexCoord4x(texture, s, t, r, q);
+        }
+    }
+}
+
+void GL_APIENTRY Normal3fContextANGLE(GLeglContext ctx, GLfloat nx, GLfloat ny, GLfloat nz)
+{
+    EVENT("(GLfloat nx = %f, GLfloat ny = %f, GLfloat nz = %f)", nx, ny, nz);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Normal3f, context, nx, ny, nz);
+        if (context->skipValidation() || ValidateNormal3f(context, nx, ny, nz))
+        {
+            context->normal3f(nx, ny, nz);
+        }
+    }
+}
+
+void GL_APIENTRY Normal3xContextANGLE(GLeglContext ctx, GLfixed nx, GLfixed ny, GLfixed nz)
+{
+    EVENT("(GLfixed nx = 0x%X, GLfixed ny = 0x%X, GLfixed nz = 0x%X)", nx, ny, nz);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Normal3x, context, nx, ny, nz);
+        if (context->skipValidation() || ValidateNormal3x(context, nx, ny, nz))
+        {
+            context->normal3x(nx, ny, nz);
+        }
+    }
+}
+
+void GL_APIENTRY NormalPointerContextANGLE(GLeglContext ctx,
+                                           GLenum type,
+                                           GLsizei stride,
+                                           const void *pointer)
+{
+    EVENT("(GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR ")",
+          type, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(NormalPointer, context, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateNormalPointer(context, typePacked, stride, pointer))
+        {
+            context->normalPointer(typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY ObjectLabelKHRContextANGLE(GLeglContext ctx,
+                                            GLenum identifier,
+                                            GLuint name,
+                                            GLsizei length,
+                                            const GLchar *label)
+{
+    EVENT(
+        "(GLenum identifier = 0x%X, GLuint name = %u, GLsizei length = %d, const GLchar *label = "
+        "0x%016" PRIxPTR ")",
+        identifier, name, length, (uintptr_t)label);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ObjectLabelKHR, context, identifier, name, length, label);
+        if (context->skipValidation() ||
+            ValidateObjectLabelKHR(context, identifier, name, length, label))
+        {
+            context->objectLabel(identifier, name, length, label);
+        }
+    }
+}
+
+void GL_APIENTRY ObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
+                                               const void *ptr,
+                                               GLsizei length,
+                                               const GLchar *label)
+{
+    EVENT("(const void *ptr = 0x%016" PRIxPTR
+          ", GLsizei length = %d, const GLchar *label = 0x%016" PRIxPTR ")",
+          (uintptr_t)ptr, length, (uintptr_t)label);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ObjectPtrLabelKHR, context, ptr, length, label);
+        if (context->skipValidation() || ValidateObjectPtrLabelKHR(context, ptr, length, label))
+        {
+            context->objectPtrLabel(ptr, length, label);
+        }
+    }
+}
+
+void GL_APIENTRY OrthofContextANGLE(GLeglContext ctx,
+                                    GLfloat l,
+                                    GLfloat r,
+                                    GLfloat b,
+                                    GLfloat t,
+                                    GLfloat n,
+                                    GLfloat f)
+{
+    EVENT(
+        "(GLfloat l = %f, GLfloat r = %f, GLfloat b = %f, GLfloat t = %f, GLfloat n = %f, GLfloat "
+        "f = %f)",
+        l, r, b, t, n, f);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Orthof, context, l, r, b, t, n, f);
+        if (context->skipValidation() || ValidateOrthof(context, l, r, b, t, n, f))
+        {
+            context->orthof(l, r, b, t, n, f);
+        }
+    }
+}
+
+void GL_APIENTRY OrthoxContextANGLE(GLeglContext ctx,
+                                    GLfixed l,
+                                    GLfixed r,
+                                    GLfixed b,
+                                    GLfixed t,
+                                    GLfixed n,
+                                    GLfixed f)
+{
+    EVENT(
+        "(GLfixed l = 0x%X, GLfixed r = 0x%X, GLfixed b = 0x%X, GLfixed t = 0x%X, GLfixed n = "
+        "0x%X, GLfixed f = 0x%X)",
+        l, r, b, t, n, f);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Orthox, context, l, r, b, t, n, f);
+        if (context->skipValidation() || ValidateOrthox(context, l, r, b, t, n, f))
+        {
+            context->orthox(l, r, b, t, n, f);
+        }
+    }
+}
+
+void GL_APIENTRY PauseTransformFeedbackContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PauseTransformFeedback, context);
+        if (context->skipValidation() || ValidatePauseTransformFeedback(context))
+        {
+            context->pauseTransformFeedback();
+        }
+    }
+}
+
+void GL_APIENTRY PixelStoreiContextANGLE(GLeglContext ctx, GLenum pname, GLint param)
+{
+    EVENT("(GLenum pname = 0x%X, GLint param = %d)", pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PixelStorei, context, pname, param);
+        if (context->skipValidation() || ValidatePixelStorei(context, pname, param))
+        {
+            context->pixelStorei(pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY PointParameterfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PointParameter pnamePacked = FromGLenum<PointParameter>(pname);
+        ANGLE_CAPTURE(PointParameterf, context, pnamePacked, param);
+        if (context->skipValidation() || ValidatePointParameterf(context, pnamePacked, param))
+        {
+            context->pointParameterf(pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY PointParameterfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PointParameter pnamePacked = FromGLenum<PointParameter>(pname);
+        ANGLE_CAPTURE(PointParameterfv, context, pnamePacked, params);
+        if (context->skipValidation() || ValidatePointParameterfv(context, pnamePacked, params))
+        {
+            context->pointParameterfv(pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY PointParameterxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum pname = 0x%X, GLfixed param = 0x%X)", pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PointParameter pnamePacked = FromGLenum<PointParameter>(pname);
+        ANGLE_CAPTURE(PointParameterx, context, pnamePacked, param);
+        if (context->skipValidation() || ValidatePointParameterx(context, pnamePacked, param))
+        {
+            context->pointParameterx(pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY PointParameterxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *params)
+{
+    EVENT("(GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")", pname,
+          (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PointParameter pnamePacked = FromGLenum<PointParameter>(pname);
+        ANGLE_CAPTURE(PointParameterxv, context, pnamePacked, params);
+        if (context->skipValidation() || ValidatePointParameterxv(context, pnamePacked, params))
+        {
+            context->pointParameterxv(pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY PointSizeContextANGLE(GLeglContext ctx, GLfloat size)
+{
+    EVENT("(GLfloat size = %f)", size);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PointSize, context, size);
+        if (context->skipValidation() || ValidatePointSize(context, size))
+        {
+            context->pointSize(size);
+        }
+    }
+}
+
+void GL_APIENTRY PointSizePointerOESContextANGLE(GLeglContext ctx,
+                                                 GLenum type,
+                                                 GLsizei stride,
+                                                 const void *pointer)
+{
+    EVENT("(GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR ")",
+          type, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(PointSizePointerOES, context, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidatePointSizePointerOES(context, typePacked, stride, pointer))
+        {
+            context->pointSizePointer(typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY PointSizexContextANGLE(GLeglContext ctx, GLfixed size)
+{
+    EVENT("(GLfixed size = 0x%X)", size);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PointSizex, context, size);
+        if (context->skipValidation() || ValidatePointSizex(context, size))
+        {
+            context->pointSizex(size);
+        }
+    }
+}
+
+void GL_APIENTRY PolygonOffsetContextANGLE(GLeglContext ctx, GLfloat factor, GLfloat units)
+{
+    EVENT("(GLfloat factor = %f, GLfloat units = %f)", factor, units);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PolygonOffset, context, factor, units);
+        if (context->skipValidation() || ValidatePolygonOffset(context, factor, units))
+        {
+            context->polygonOffset(factor, units);
+        }
+    }
+}
+
+void GL_APIENTRY PolygonOffsetxContextANGLE(GLeglContext ctx, GLfixed factor, GLfixed units)
+{
+    EVENT("(GLfixed factor = 0x%X, GLfixed units = 0x%X)", factor, units);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PolygonOffsetx, context, factor, units);
+        if (context->skipValidation() || ValidatePolygonOffsetx(context, factor, units))
+        {
+            context->polygonOffsetx(factor, units);
+        }
+    }
+}
+
+void GL_APIENTRY PopDebugGroupKHRContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PopDebugGroupKHR, context);
+        if (context->skipValidation() || ValidatePopDebugGroupKHR(context))
+        {
+            context->popDebugGroup();
+        }
+    }
+}
+
+void GL_APIENTRY PopGroupMarkerEXTContextANGLE(GLeglContext ctx)
+{
+    // Don't run an EVENT() macro on the EXT_debug_marker entry points.
+    // It can interfere with the debug events being set by the caller.
+    // EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PopGroupMarkerEXT, context);
+        if (context->skipValidation() || ValidatePopGroupMarkerEXT(context))
+        {
+            context->popGroupMarker();
+        }
+    }
+}
+
+void GL_APIENTRY PopMatrixContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PopMatrix, context);
+        if (context->skipValidation() || ValidatePopMatrix(context))
+        {
+            context->popMatrix();
+        }
+    }
+}
+
+void GL_APIENTRY ProgramBinaryContextANGLE(GLeglContext ctx,
+                                           GLuint program,
+                                           GLenum binaryFormat,
+                                           const void *binary,
+                                           GLsizei length)
+{
+    EVENT("(GLuint program = %u, GLenum binaryFormat = 0x%X, const void *binary = 0x%016" PRIxPTR
+          ", GLsizei length = %d)",
+          program, binaryFormat, (uintptr_t)binary, length);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramBinary, context, program, binaryFormat, binary, length);
+        if (context->skipValidation() ||
+            ValidateProgramBinary(context, program, binaryFormat, binary, length))
+        {
+            context->programBinary(program, binaryFormat, binary, length);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramBinaryOESContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLenum binaryFormat,
+                                              const void *binary,
+                                              GLint length)
+{
+    EVENT("(GLuint program = %u, GLenum binaryFormat = 0x%X, const void *binary = 0x%016" PRIxPTR
+          ", GLint length = %d)",
+          program, binaryFormat, (uintptr_t)binary, length);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramBinaryOES, context, program, binaryFormat, binary, length);
+        if (context->skipValidation() ||
+            ValidateProgramBinaryOES(context, program, binaryFormat, binary, length))
+        {
+            context->programBinary(program, binaryFormat, binary, length);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramParameteriContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLenum pname,
+                                               GLint value)
+{
+    EVENT("(GLuint program = %u, GLenum pname = 0x%X, GLint value = %d)", program, pname, value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramParameteri, context, program, pname, value);
+        if (context->skipValidation() || ValidateProgramParameteri(context, program, pname, value))
+        {
+            context->programParameteri(program, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1fContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLfloat v0)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLfloat v0 = %f)", program, location, v0);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform1f, context, program, location, v0);
+        if (context->skipValidation() || ValidateProgramUniform1f(context, program, location, v0))
+        {
+            context->programUniform1f(program, location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1fvContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLsizei count,
+                                               const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform1fv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform1fv(context, program, location, count, value))
+        {
+            context->programUniform1fv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1iContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLint v0)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d)", program, location, v0);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform1i, context, program, location, v0);
+        if (context->skipValidation() || ValidateProgramUniform1i(context, program, location, v0))
+        {
+            context->programUniform1i(program, location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1ivContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLsizei count,
+                                               const GLint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform1iv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform1iv(context, program, location, count, value))
+        {
+            context->programUniform1iv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1uiContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLuint v0)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLuint v0 = %u)", program, location, v0);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform1ui, context, program, location, v0);
+        if (context->skipValidation() || ValidateProgramUniform1ui(context, program, location, v0))
+        {
+            context->programUniform1ui(program, location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform1uivContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLuint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform1uiv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform1uiv(context, program, location, count, value))
+        {
+            context->programUniform1uiv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2fContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLfloat v0,
+                                              GLfloat v1)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f)", program,
+          location, v0, v1);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform2f, context, program, location, v0, v1);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2f(context, program, location, v0, v1))
+        {
+            context->programUniform2f(program, location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2fvContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLsizei count,
+                                               const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform2fv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2fv(context, program, location, count, value))
+        {
+            context->programUniform2fv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+ProgramUniform2iContextANGLE(GLeglContext ctx, GLuint program, GLint location, GLint v0, GLint v1)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d)", program,
+          location, v0, v1);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform2i, context, program, location, v0, v1);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2i(context, program, location, v0, v1))
+        {
+            context->programUniform2i(program, location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2ivContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLsizei count,
+                                               const GLint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform2iv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2iv(context, program, location, count, value))
+        {
+            context->programUniform2iv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2uiContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLuint v0,
+                                               GLuint v1)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u)", program,
+          location, v0, v1);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform2ui, context, program, location, v0, v1);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2ui(context, program, location, v0, v1))
+        {
+            context->programUniform2ui(program, location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2uivContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLuint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform2uiv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform2uiv(context, program, location, count, value))
+        {
+            context->programUniform2uiv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3fContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLfloat v0,
+                                              GLfloat v1,
+                                              GLfloat v2)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
+        "%f)",
+        program, location, v0, v1, v2);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform3f, context, program, location, v0, v1, v2);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3f(context, program, location, v0, v1, v2))
+        {
+            context->programUniform3f(program, location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3fvContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLsizei count,
+                                               const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform3fv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3fv(context, program, location, count, value))
+        {
+            context->programUniform3fv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3iContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLint v0,
+                                              GLint v1,
+                                              GLint v2)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d)",
+          program, location, v0, v1, v2);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform3i, context, program, location, v0, v1, v2);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3i(context, program, location, v0, v1, v2))
+        {
+            context->programUniform3i(program, location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3ivContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLsizei count,
+                                               const GLint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform3iv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3iv(context, program, location, count, value))
+        {
+            context->programUniform3iv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3uiContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLuint v0,
+                                               GLuint v1,
+                                               GLuint v2)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
+        "%u)",
+        program, location, v0, v1, v2);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform3ui, context, program, location, v0, v1, v2);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3ui(context, program, location, v0, v1, v2))
+        {
+            context->programUniform3ui(program, location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform3uivContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLuint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform3uiv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform3uiv(context, program, location, count, value))
+        {
+            context->programUniform3uiv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4fContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLfloat v0,
+                                              GLfloat v1,
+                                              GLfloat v2,
+                                              GLfloat v3)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
+        "%f, GLfloat v3 = %f)",
+        program, location, v0, v1, v2, v3);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform4f, context, program, location, v0, v1, v2, v3);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4f(context, program, location, v0, v1, v2, v3))
+        {
+            context->programUniform4f(program, location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4fvContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLsizei count,
+                                               const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform4fv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4fv(context, program, location, count, value))
+        {
+            context->programUniform4fv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4iContextANGLE(GLeglContext ctx,
+                                              GLuint program,
+                                              GLint location,
+                                              GLint v0,
+                                              GLint v1,
+                                              GLint v2,
+                                              GLint v3)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, "
+        "GLint v3 = %d)",
+        program, location, v0, v1, v2, v3);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform4i, context, program, location, v0, v1, v2, v3);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4i(context, program, location, v0, v1, v2, v3))
+        {
+            context->programUniform4i(program, location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4ivContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLsizei count,
+                                               const GLint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform4iv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4iv(context, program, location, count, value))
+        {
+            context->programUniform4iv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4uiContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLint location,
+                                               GLuint v0,
+                                               GLuint v1,
+                                               GLuint v2,
+                                               GLuint v3)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
+        "%u, GLuint v3 = %u)",
+        program, location, v0, v1, v2, v3);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform4ui, context, program, location, v0, v1, v2, v3);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4ui(context, program, location, v0, v1, v2, v3))
+        {
+            context->programUniform4ui(program, location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform4uivContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLuint *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%016" PRIxPTR ")",
+        program, location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniform4uiv, context, program, location, count, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniform4uiv(context, program, location, count, value))
+        {
+            context->programUniform4uiv(program, location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix2fvContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     GLboolean transpose,
+                                                     const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix2fv, context, program, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix2fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix2fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix2x3fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix2x3fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix2x3fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix2x4fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix2x4fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix2x4fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix3fvContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     GLboolean transpose,
+                                                     const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix3fv, context, program, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix3fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix3fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix3x2fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix3x2fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix3x2fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix3x4fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix3x4fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix3x4fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix4fvContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     GLboolean transpose,
+                                                     const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix4fv, context, program, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix4fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix4fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix4x2fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix4x2fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix4x2fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniformMatrix4x3fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%016" PRIxPTR ")",
+        program, location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, context, program, location, count, transpose,
+                      value);
+        if (context->skipValidation() ||
+            ValidateProgramUniformMatrix4x3fv(context, program, location, count, transpose, value))
+        {
+            context->programUniformMatrix4x3fv(program, location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY PushDebugGroupKHRContextANGLE(GLeglContext ctx,
+                                               GLenum source,
+                                               GLuint id,
+                                               GLsizei length,
+                                               const GLchar *message)
+{
+    EVENT(
+        "(GLenum source = 0x%X, GLuint id = %u, GLsizei length = %d, const GLchar *message = "
+        "0x%016" PRIxPTR ")",
+        source, id, length, (uintptr_t)message);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PushDebugGroupKHR, context, source, id, length, message);
+        if (context->skipValidation() ||
+            ValidatePushDebugGroupKHR(context, source, id, length, message))
+        {
+            context->pushDebugGroup(source, id, length, message);
+        }
+    }
+}
+
+void GL_APIENTRY PushGroupMarkerEXTContextANGLE(GLeglContext ctx,
+                                                GLsizei length,
+                                                const GLchar *marker)
+{
+    // Don't run an EVENT() macro on the EXT_debug_marker entry points.
+    // It can interfere with the debug events being set by the caller.
+    // EVENT("(GLsizei length = %d, const GLchar *marker = 0x%016" PRIxPTR ")", length,
+    // (uintptr_t)marker);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PushGroupMarkerEXT, context, length, marker);
+        if (context->skipValidation() || ValidatePushGroupMarkerEXT(context, length, marker))
+        {
+            context->pushGroupMarker(length, marker);
+        }
+    }
+}
+
+void GL_APIENTRY PushMatrixContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PushMatrix, context);
+        if (context->skipValidation() || ValidatePushMatrix(context))
+        {
+            context->pushMatrix();
+        }
+    }
+}
+
+void GL_APIENTRY QueryCounterEXTContextANGLE(GLeglContext ctx, GLuint id, GLenum target)
+{
+    EVENT("(GLuint id = %u, GLenum target = 0x%X)", id, target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(QueryCounterEXT, context, id, targetPacked);
+        if (context->skipValidation() || ValidateQueryCounterEXT(context, id, targetPacked))
+        {
+            context->queryCounter(id, targetPacked);
+        }
+    }
+}
+
+GLbitfield GL_APIENTRY QueryMatrixxOESContextANGLE(GLeglContext ctx,
+                                                   GLfixed *mantissa,
+                                                   GLint *exponent)
+{
+    EVENT("(GLfixed *mantissa = 0x%016" PRIxPTR ", GLint *exponent = 0x%016" PRIxPTR ")",
+          (uintptr_t)mantissa, (uintptr_t)exponent);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(QueryMatrixxOES, context, mantissa, exponent);
+        if (context->skipValidation() || ValidateQueryMatrixxOES(context, mantissa, exponent))
+        {
+            return context->queryMatrixx(mantissa, exponent);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::QueryMatrixxOES, GLbitfield>();
+}
+
+void GL_APIENTRY ReadBufferContextANGLE(GLeglContext ctx, GLenum src)
+{
+    EVENT("(GLenum src = 0x%X)", src);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ReadBuffer, context, src);
+        if (context->skipValidation() || ValidateReadBuffer(context, src))
+        {
+            context->readBuffer(src);
+        }
+    }
+}
+
+void GL_APIENTRY ReadPixelsContextANGLE(GLeglContext ctx,
+                                        GLint x,
+                                        GLint y,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLenum format,
+                                        GLenum type,
+                                        void *pixels)
+{
+    EVENT(
+        "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = "
+        "0x%X, GLenum type = 0x%X, void *pixels = 0x%016" PRIxPTR ")",
+        x, y, width, height, format, type, (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ReadPixels, context, x, y, width, height, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateReadPixels(context, x, y, width, height, format, type, pixels))
+        {
+            context->readPixels(x, y, width, height, format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY ReadnPixelsEXTContextANGLE(GLeglContext ctx,
+                                            GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            GLsizei bufSize,
+                                            void *data)
+{
+    EVENT(
+        "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = "
+        "0x%X, GLenum type = 0x%X, GLsizei bufSize = %d, void *data = 0x%016" PRIxPTR ")",
+        x, y, width, height, format, type, bufSize, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ReadnPixelsEXT, context, x, y, width, height, format, type, bufSize, data);
+        if (context->skipValidation() ||
+            ValidateReadnPixelsEXT(context, x, y, width, height, format, type, bufSize, data))
+        {
+            context->readnPixels(x, y, width, height, format, type, bufSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY ReleaseShaderCompilerContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ReleaseShaderCompiler, context);
+        if (context->skipValidation() || ValidateReleaseShaderCompiler(context))
+        {
+            context->releaseShaderCompiler();
+        }
+    }
+}
+
+void GL_APIENTRY RenderbufferStorageContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLenum internalformat,
+                                                 GLsizei width,
+                                                 GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = "
+        "%d)",
+        target, internalformat, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(RenderbufferStorage, context, target, internalformat, width, height);
+        if (context->skipValidation() ||
+            ValidateRenderbufferStorage(context, target, internalformat, width, height))
+        {
+            context->renderbufferStorage(target, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY RenderbufferStorageMultisampleContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLsizei samples,
+                                                            GLenum internalformat,
+                                                            GLsizei width,
+                                                            GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d)",
+        target, samples, internalformat, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(RenderbufferStorageMultisample, context, target, samples, internalformat,
+                      width, height);
+        if (context->skipValidation() ||
+            ValidateRenderbufferStorageMultisample(context, target, samples, internalformat, width,
+                                                   height))
+        {
+            context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY RenderbufferStorageMultisampleANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLsizei samples,
+                                                                 GLenum internalformat,
+                                                                 GLsizei width,
+                                                                 GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d)",
+        target, samples, internalformat, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(RenderbufferStorageMultisampleANGLE, context, target, samples, internalformat,
+                      width, height);
+        if (context->skipValidation() ||
+            ValidateRenderbufferStorageMultisampleANGLE(context, target, samples, internalformat,
+                                                        width, height))
+        {
+            context->renderbufferStorageMultisample(target, samples, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY RenderbufferStorageOESContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLenum internalformat,
+                                                    GLsizei width,
+                                                    GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = "
+        "%d)",
+        target, internalformat, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(RenderbufferStorageOES, context, target, internalformat, width, height);
+        if (context->skipValidation() ||
+            ValidateRenderbufferStorageOES(context, target, internalformat, width, height))
+        {
+            context->renderbufferStorage(target, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY ResumeTransformFeedbackContextANGLE(GLeglContext ctx)
+{
+    EVENT("()");
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ResumeTransformFeedback, context);
+        if (context->skipValidation() || ValidateResumeTransformFeedback(context))
+        {
+            context->resumeTransformFeedback();
+        }
+    }
+}
+
+void GL_APIENTRY
+RotatefContextANGLE(GLeglContext ctx, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+    EVENT("(GLfloat angle = %f, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", angle, x, y, z);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Rotatef, context, angle, x, y, z);
+        if (context->skipValidation() || ValidateRotatef(context, angle, x, y, z))
+        {
+            context->rotatef(angle, x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY
+RotatexContextANGLE(GLeglContext ctx, GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
+{
+    EVENT("(GLfixed angle = 0x%X, GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X)", angle, x,
+          y, z);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Rotatex, context, angle, x, y, z);
+        if (context->skipValidation() || ValidateRotatex(context, angle, x, y, z))
+        {
+            context->rotatex(angle, x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY SampleCoverageContextANGLE(GLeglContext ctx, GLfloat value, GLboolean invert)
+{
+    EVENT("(GLfloat value = %f, GLboolean invert = %u)", value, invert);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SampleCoverage, context, value, invert);
+        if (context->skipValidation() || ValidateSampleCoverage(context, value, invert))
+        {
+            context->sampleCoverage(value, invert);
+        }
+    }
+}
+
+void GL_APIENTRY SampleCoveragexContextANGLE(GLeglContext ctx, GLclampx value, GLboolean invert)
+{
+    EVENT("(GLclampx value = 0x%X, GLboolean invert = %u)", value, invert);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SampleCoveragex, context, value, invert);
+        if (context->skipValidation() || ValidateSampleCoveragex(context, value, invert))
+        {
+            context->sampleCoveragex(value, invert);
+        }
+    }
+}
+
+void GL_APIENTRY SampleMaskiContextANGLE(GLeglContext ctx, GLuint maskNumber, GLbitfield mask)
+{
+    EVENT("(GLuint maskNumber = %u, GLbitfield mask = 0x%X)", maskNumber, mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SampleMaski, context, maskNumber, mask);
+        if (context->skipValidation() || ValidateSampleMaski(context, maskNumber, mask))
+        {
+            context->sampleMaski(maskNumber, mask);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterIivOESContextANGLE(GLeglContext ctx,
+                                                    GLuint sampler,
+                                                    GLenum pname,
+                                                    const GLint *param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLint *param = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameterIivOES, context, sampler, pname, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterIivOES(context, sampler, pname, param))
+        {
+            context->samplerParameterIiv(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                     GLuint sampler,
+                                                     GLenum pname,
+                                                     const GLuint *param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLuint *param = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameterIuivOES, context, sampler, pname, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterIuivOES(context, sampler, pname, param))
+        {
+            context->samplerParameterIuiv(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterfContextANGLE(GLeglContext ctx,
+                                               GLuint sampler,
+                                               GLenum pname,
+                                               GLfloat param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLfloat param = %f)", sampler, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameterf, context, sampler, pname, param);
+        if (context->skipValidation() || ValidateSamplerParameterf(context, sampler, pname, param))
+        {
+            context->samplerParameterf(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterfvContextANGLE(GLeglContext ctx,
+                                                GLuint sampler,
+                                                GLenum pname,
+                                                const GLfloat *param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLfloat *param = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameterfv, context, sampler, pname, param);
+        if (context->skipValidation() || ValidateSamplerParameterfv(context, sampler, pname, param))
+        {
+            context->samplerParameterfv(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameteriContextANGLE(GLeglContext ctx,
+                                               GLuint sampler,
+                                               GLenum pname,
+                                               GLint param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, GLint param = %d)", sampler, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameteri, context, sampler, pname, param);
+        if (context->skipValidation() || ValidateSamplerParameteri(context, sampler, pname, param))
+        {
+            context->samplerParameteri(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterivContextANGLE(GLeglContext ctx,
+                                                GLuint sampler,
+                                                GLenum pname,
+                                                const GLint *param)
+{
+    EVENT("(GLuint sampler = %u, GLenum pname = 0x%X, const GLint *param = 0x%016" PRIxPTR ")",
+          sampler, pname, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameteriv, context, sampler, pname, param);
+        if (context->skipValidation() || ValidateSamplerParameteriv(context, sampler, pname, param))
+        {
+            context->samplerParameteriv(sampler, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY ScalefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z)
+{
+    EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Scalef, context, x, y, z);
+        if (context->skipValidation() || ValidateScalef(context, x, y, z))
+        {
+            context->scalef(x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY ScalexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z)
+{
+    EVENT("(GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X)", x, y, z);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Scalex, context, x, y, z);
+        if (context->skipValidation() || ValidateScalex(context, x, y, z))
+        {
+            context->scalex(x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY
+ScissorContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width,
+          height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Scissor, context, x, y, width, height);
+        if (context->skipValidation() || ValidateScissor(context, x, y, width, height))
+        {
+            context->scissor(x, y, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY SemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
+                                                        GLuint semaphore,
+                                                        GLenum pname,
+                                                        const GLuint64 *params)
+{
+    EVENT("(GLuint semaphore = %u, GLenum pname = 0x%X, const GLuint64 *params = 0x%016" PRIxPTR
+          ")",
+          semaphore, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SemaphoreParameterui64vEXT, context, semaphore, pname, params);
+        if (context->skipValidation() ||
+            ValidateSemaphoreParameterui64vEXT(context, semaphore, pname, params))
+        {
+            context->semaphoreParameterui64v(semaphore, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY SetFenceNVContextANGLE(GLeglContext ctx, GLuint fence, GLenum condition)
+{
+    EVENT("(GLuint fence = %u, GLenum condition = 0x%X)", fence, condition);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SetFenceNV, context, fence, condition);
+        if (context->skipValidation() || ValidateSetFenceNV(context, fence, condition))
+        {
+            context->setFenceNV(fence, condition);
+        }
+    }
+}
+
+void GL_APIENTRY ShadeModelContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ShadingModel modePacked = FromGLenum<ShadingModel>(mode);
+        ANGLE_CAPTURE(ShadeModel, context, modePacked);
+        if (context->skipValidation() || ValidateShadeModel(context, modePacked))
+        {
+            context->shadeModel(modePacked);
+        }
+    }
+}
+
+void GL_APIENTRY ShaderBinaryContextANGLE(GLeglContext ctx,
+                                          GLsizei count,
+                                          const GLuint *shaders,
+                                          GLenum binaryformat,
+                                          const void *binary,
+                                          GLsizei length)
+{
+    EVENT("(GLsizei count = %d, const GLuint *shaders = 0x%016" PRIxPTR
+          ", GLenum binaryformat = 0x%X, const void *binary = 0x%016" PRIxPTR
+          ", GLsizei length = %d)",
+          count, (uintptr_t)shaders, binaryformat, (uintptr_t)binary, length);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ShaderBinary, context, count, shaders, binaryformat, binary, length);
+        if (context->skipValidation() ||
+            ValidateShaderBinary(context, count, shaders, binaryformat, binary, length))
+        {
+            context->shaderBinary(count, shaders, binaryformat, binary, length);
+        }
+    }
+}
+
+void GL_APIENTRY ShaderSourceContextANGLE(GLeglContext ctx,
+                                          GLuint shader,
+                                          GLsizei count,
+                                          const GLchar *const *string,
+                                          const GLint *length)
+{
+    EVENT("(GLuint shader = %u, GLsizei count = %d, const GLchar *const*string = 0x%016" PRIxPTR
+          ", const GLint *length = 0x%016" PRIxPTR ")",
+          shader, count, (uintptr_t)string, (uintptr_t)length);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ShaderSource, context, shader, count, string, length);
+        if (context->skipValidation() ||
+            ValidateShaderSource(context, shader, count, string, length))
+        {
+            context->shaderSource(shader, count, string, length);
+        }
+    }
+}
+
+void GL_APIENTRY SignalSemaphoreEXTContextANGLE(GLeglContext ctx,
+                                                GLuint semaphore,
+                                                GLuint numBufferBarriers,
+                                                const GLuint *buffers,
+                                                GLuint numTextureBarriers,
+                                                const GLuint *textures,
+                                                const GLenum *dstLayouts)
+{
+    EVENT(
+        "(GLuint semaphore = %u, GLuint numBufferBarriers = %u, const GLuint *buffers = "
+        "0x%016" PRIxPTR ", GLuint numTextureBarriers = %u, const GLuint *textures = 0x%016" PRIxPTR
+        ", const GLenum *dstLayouts = 0x%016" PRIxPTR ")",
+        semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers, (uintptr_t)textures,
+        (uintptr_t)dstLayouts);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SignalSemaphoreEXT, context, semaphore, numBufferBarriers, buffers,
+                      numTextureBarriers, textures, dstLayouts);
+        if (context->skipValidation() ||
+            ValidateSignalSemaphoreEXT(context, semaphore, numBufferBarriers, buffers,
+                                       numTextureBarriers, textures, dstLayouts))
+        {
+            context->signalSemaphore(semaphore, numBufferBarriers, buffers, numTextureBarriers,
+                                     textures, dstLayouts);
+        }
+    }
+}
+
+void GL_APIENTRY StencilFuncContextANGLE(GLeglContext ctx, GLenum func, GLint ref, GLuint mask)
+{
+    EVENT("(GLenum func = 0x%X, GLint ref = %d, GLuint mask = %u)", func, ref, mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilFunc, context, func, ref, mask);
+        if (context->skipValidation() || ValidateStencilFunc(context, func, ref, mask))
+        {
+            context->stencilFunc(func, ref, mask);
+        }
+    }
+}
+
+void GL_APIENTRY
+StencilFuncSeparateContextANGLE(GLeglContext ctx, GLenum face, GLenum func, GLint ref, GLuint mask)
+{
+    EVENT("(GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %u)", face, func,
+          ref, mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilFuncSeparate, context, face, func, ref, mask);
+        if (context->skipValidation() ||
+            ValidateStencilFuncSeparate(context, face, func, ref, mask))
+        {
+            context->stencilFuncSeparate(face, func, ref, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilMaskContextANGLE(GLeglContext ctx, GLuint mask)
+{
+    EVENT("(GLuint mask = %u)", mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilMask, context, mask);
+        if (context->skipValidation() || ValidateStencilMask(context, mask))
+        {
+            context->stencilMask(mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilMaskSeparateContextANGLE(GLeglContext ctx, GLenum face, GLuint mask)
+{
+    EVENT("(GLenum face = 0x%X, GLuint mask = %u)", face, mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilMaskSeparate, context, face, mask);
+        if (context->skipValidation() || ValidateStencilMaskSeparate(context, face, mask))
+        {
+            context->stencilMaskSeparate(face, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilOpContextANGLE(GLeglContext ctx, GLenum fail, GLenum zfail, GLenum zpass)
+{
+    EVENT("(GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpass = 0x%X)", fail, zfail, zpass);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilOp, context, fail, zfail, zpass);
+        if (context->skipValidation() || ValidateStencilOp(context, fail, zfail, zpass))
+        {
+            context->stencilOp(fail, zfail, zpass);
+        }
+    }
+}
+
+void GL_APIENTRY StencilOpSeparateContextANGLE(GLeglContext ctx,
+                                               GLenum face,
+                                               GLenum sfail,
+                                               GLenum dpfail,
+                                               GLenum dppass)
+{
+    EVENT("(GLenum face = 0x%X, GLenum sfail = 0x%X, GLenum dpfail = 0x%X, GLenum dppass = 0x%X)",
+          face, sfail, dpfail, dppass);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilOpSeparate, context, face, sfail, dpfail, dppass);
+        if (context->skipValidation() ||
+            ValidateStencilOpSeparate(context, face, sfail, dpfail, dppass))
+        {
+            context->stencilOpSeparate(face, sfail, dpfail, dppass);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY TestFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
+{
+    EVENT("(GLuint fence = %u)", fence);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TestFenceNV, context, fence);
+        if (context->skipValidation() || ValidateTestFenceNV(context, fence))
+        {
+            return context->testFenceNV(fence);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::TestFenceNV, GLboolean>();
+}
+
+void GL_APIENTRY TexCoordPointerContextANGLE(GLeglContext ctx,
+                                             GLint size,
+                                             GLenum type,
+                                             GLsizei stride,
+                                             const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(TexCoordPointer, context, size, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateTexCoordPointer(context, size, typePacked, stride, pointer))
+        {
+            context->texCoordPointer(size, typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvfContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", target, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvf, context, targetPacked, pnamePacked, param);
+        if (context->skipValidation() || ValidateTexEnvf(context, targetPacked, pnamePacked, param))
+        {
+            context->texEnvf(targetPacked, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvfvContextANGLE(GLeglContext ctx,
+                                      GLenum target,
+                                      GLenum pname,
+                                      const GLfloat *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvfv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateTexEnvfv(context, targetPacked, pnamePacked, params))
+        {
+            context->texEnvfv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnviContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLint param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvi, context, targetPacked, pnamePacked, param);
+        if (context->skipValidation() || ValidateTexEnvi(context, targetPacked, pnamePacked, param))
+        {
+            context->texEnvi(targetPacked, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvivContextANGLE(GLeglContext ctx,
+                                      GLenum target,
+                                      GLenum pname,
+                                      const GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnviv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateTexEnviv(context, targetPacked, pnamePacked, params))
+        {
+            context->texEnviv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvxContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", target, pname,
+          param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvx, context, targetPacked, pnamePacked, param);
+        if (context->skipValidation() || ValidateTexEnvx(context, targetPacked, pnamePacked, param))
+        {
+            context->texEnvx(targetPacked, pnamePacked, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexEnvxvContextANGLE(GLeglContext ctx,
+                                      GLenum target,
+                                      GLenum pname,
+                                      const GLfixed *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureEnvTarget targetPacked   = FromGLenum<TextureEnvTarget>(target);
+        TextureEnvParameter pnamePacked = FromGLenum<TextureEnvParameter>(pname);
+        ANGLE_CAPTURE(TexEnvxv, context, targetPacked, pnamePacked, params);
+        if (context->skipValidation() ||
+            ValidateTexEnvxv(context, targetPacked, pnamePacked, params))
+        {
+            context->texEnvxv(targetPacked, pnamePacked, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenfOESContextANGLE(GLeglContext ctx, GLenum coord, GLenum pname, GLfloat param)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", coord, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TexGenfOES, context, coord, pname, param);
+        if (context->skipValidation() || ValidateTexGenfOES(context, coord, pname, param))
+        {
+            context->texGenf(coord, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenfvOESContextANGLE(GLeglContext ctx,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         const GLfloat *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          coord, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TexGenfvOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateTexGenfvOES(context, coord, pname, params))
+        {
+            context->texGenfv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexGeniOESContextANGLE(GLeglContext ctx, GLenum coord, GLenum pname, GLint param)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLint param = %d)", coord, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TexGeniOES, context, coord, pname, param);
+        if (context->skipValidation() || ValidateTexGeniOES(context, coord, pname, param))
+        {
+            context->texGeni(coord, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenivOESContextANGLE(GLeglContext ctx,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         const GLint *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR ")",
+          coord, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TexGenivOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateTexGenivOES(context, coord, pname, params))
+        {
+            context->texGeniv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenxOESContextANGLE(GLeglContext ctx, GLenum coord, GLenum pname, GLfixed param)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", coord, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TexGenxOES, context, coord, pname, param);
+        if (context->skipValidation() || ValidateTexGenxOES(context, coord, pname, param))
+        {
+            context->texGenx(coord, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexGenxvOESContextANGLE(GLeglContext ctx,
+                                         GLenum coord,
+                                         GLenum pname,
+                                         const GLfixed *params)
+{
+    EVENT("(GLenum coord = 0x%X, GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")",
+          coord, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TexGenxvOES, context, coord, pname, params);
+        if (context->skipValidation() || ValidateTexGenxvOES(context, coord, pname, params))
+        {
+            context->texGenxv(coord, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage2DContextANGLE(GLeglContext ctx,
+                                        GLenum target,
+                                        GLint level,
+                                        GLint internalformat,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLint border,
+                                        GLenum format,
+                                        GLenum type,
+                                        const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const "
+        "void *pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, border, format, type, (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage2D, context, targetPacked, level, internalformat, width, height,
+                      border, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage2D(context, targetPacked, level, internalformat, width, height, border,
+                               format, type, pixels))
+        {
+            context->texImage2D(targetPacked, level, internalformat, width, height, border, format,
+                                type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage3DContextANGLE(GLeglContext ctx,
+                                        GLenum target,
+                                        GLint level,
+                                        GLint internalformat,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLsizei depth,
+                                        GLint border,
+                                        GLenum format,
+                                        GLenum type,
+                                        const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, GLenum "
+        "type = 0x%X, const void *pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, format, type,
+        (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage3D, context, targetPacked, level, internalformat, width, height,
+                      depth, border, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage3D(context, targetPacked, level, internalformat, width, height, depth,
+                               border, format, type, pixels))
+        {
+            context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
+                                format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage3DOESContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLint level,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth,
+                                           GLint border,
+                                           GLenum format,
+                                           GLenum type,
+                                           const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, "
+        "GLenum type = 0x%X, const void *pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, format, type,
+        (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage3DOES, context, targetPacked, level, internalformat, width, height,
+                      depth, border, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage3DOES(context, targetPacked, level, internalformat, width, height,
+                                  depth, border, format, type, pixels))
+        {
+            context->texImage3D(targetPacked, level, internalformat, width, height, depth, border,
+                                format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterIivOESContextANGLE(GLeglContext ctx,
+                                                GLenum target,
+                                                GLenum pname,
+                                                const GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterIivOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterIivOES(context, targetPacked, pname, params))
+        {
+            context->texParameterIiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLenum pname,
+                                                 const GLuint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLuint *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterIuivOES, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterIuivOES(context, targetPacked, pname, params))
+        {
+            context->texParameterIuiv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterfContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLenum pname,
+                                           GLfloat param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat param = %f)", target, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterf, context, targetPacked, pname, param);
+        if (context->skipValidation() || ValidateTexParameterf(context, targetPacked, pname, param))
+        {
+            context->texParameterf(targetPacked, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterfvContextANGLE(GLeglContext ctx,
+                                            GLenum target,
+                                            GLenum pname,
+                                            const GLfloat *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLfloat *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterfv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterfv(context, targetPacked, pname, params))
+        {
+            context->texParameterfv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameteriContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLenum pname,
+                                           GLint param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameteri, context, targetPacked, pname, param);
+        if (context->skipValidation() || ValidateTexParameteri(context, targetPacked, pname, param))
+        {
+            context->texParameteri(targetPacked, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterivContextANGLE(GLeglContext ctx,
+                                            GLenum target,
+                                            GLenum pname,
+                                            const GLint *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLint *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameteriv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameteriv(context, targetPacked, pname, params))
+        {
+            context->texParameteriv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterxContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLenum pname,
+                                           GLfixed param)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfixed param = 0x%X)", target, pname,
+          param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterx, context, targetPacked, pname, param);
+        if (context->skipValidation() || ValidateTexParameterx(context, targetPacked, pname, param))
+        {
+            context->texParameterx(targetPacked, pname, param);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterxvContextANGLE(GLeglContext ctx,
+                                            GLenum target,
+                                            GLenum pname,
+                                            const GLfixed *params)
+{
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, const GLfixed *params = 0x%016" PRIxPTR ")",
+          target, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterxv, context, targetPacked, pname, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterxv(context, targetPacked, pname, params))
+        {
+            context->texParameterxv(targetPacked, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage1DEXTContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLsizei levels,
+                                             GLenum internalformat,
+                                             GLsizei width)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d)",
+        target, levels, internalformat, width);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TexStorage1DEXT, context, target, levels, internalformat, width);
+        if (context->skipValidation() ||
+            ValidateTexStorage1DEXT(context, target, levels, internalformat, width))
+        {
+            context->texStorage1D(target, levels, internalformat, width);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage2DContextANGLE(GLeglContext ctx,
+                                          GLenum target,
+                                          GLsizei levels,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d)",
+        target, levels, internalformat, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage2D, context, targetPacked, levels, internalformat, width, height);
+        if (context->skipValidation() ||
+            ValidateTexStorage2D(context, targetPacked, levels, internalformat, width, height))
+        {
+            context->texStorage2D(targetPacked, levels, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage2DEXTContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLsizei levels,
+                                             GLenum internalformat,
+                                             GLsizei width,
+                                             GLsizei height)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d)",
+        target, levels, internalformat, width, height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage2DEXT, context, targetPacked, levels, internalformat, width,
+                      height);
+        if (context->skipValidation() ||
+            ValidateTexStorage2DEXT(context, targetPacked, levels, internalformat, width, height))
+        {
+            context->texStorage2D(targetPacked, levels, internalformat, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage2DMultisampleContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLsizei samples,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLboolean fixedsamplelocations)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLboolean fixedsamplelocations = %u)",
+        target, samples, internalformat, width, height, fixedsamplelocations);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage2DMultisample, context, targetPacked, samples, internalformat,
+                      width, height, fixedsamplelocations);
+        if (context->skipValidation() ||
+            ValidateTexStorage2DMultisample(context, targetPacked, samples, internalformat, width,
+                                            height, fixedsamplelocations))
+        {
+            context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
+                                             fixedsamplelocations);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage3DContextANGLE(GLeglContext ctx,
+                                          GLenum target,
+                                          GLsizei levels,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLsizei depth)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d)",
+        target, levels, internalformat, width, height, depth);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage3D, context, targetPacked, levels, internalformat, width, height,
+                      depth);
+        if (context->skipValidation() || ValidateTexStorage3D(context, targetPacked, levels,
+                                                              internalformat, width, height, depth))
+        {
+            context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage3DEXTContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLsizei levels,
+                                             GLenum internalformat,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLsizei depth)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d)",
+        target, levels, internalformat, width, height, depth);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage3DEXT, context, targetPacked, levels, internalformat, width, height,
+                      depth);
+        if (context->skipValidation() ||
+            ValidateTexStorage3DEXT(context, targetPacked, levels, internalformat, width, height,
+                                    depth))
+        {
+            context->texStorage3D(targetPacked, levels, internalformat, width, height, depth);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage3DMultisampleOESContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLsizei samples,
+                                                        GLenum internalformat,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLsizei depth,
+                                                        GLboolean fixedsamplelocations)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLsizei depth = %d, GLboolean fixedsamplelocations = %u)",
+        target, samples, internalformat, width, height, depth, fixedsamplelocations);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage3DMultisampleOES, context, targetPacked, samples, internalformat,
+                      width, height, depth, fixedsamplelocations);
+        if (context->skipValidation() ||
+            ValidateTexStorage3DMultisampleOES(context, targetPacked, samples, internalformat,
+                                               width, height, depth, fixedsamplelocations))
+        {
+            context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height,
+                                             depth, fixedsamplelocations);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorageMem2DEXTContextANGLE(GLeglContext ctx,
+                                                GLenum target,
+                                                GLsizei levels,
+                                                GLenum internalFormat,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLuint memory,
+                                                GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalFormat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLuint memory = %u, GLuint64 offset = %llu)",
+        target, levels, internalFormat, width, height, memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorageMem2DEXT, context, targetPacked, levels, internalFormat, width,
+                      height, memory, offset);
+        if (context->skipValidation() ||
+            ValidateTexStorageMem2DEXT(context, targetPacked, levels, internalFormat, width, height,
+                                       memory, offset))
+        {
+            context->texStorageMem2D(targetPacked, levels, internalFormat, width, height, memory,
+                                     offset);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorageMem2DMultisampleEXTContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLsizei samples,
+                                                           GLenum internalFormat,
+                                                           GLsizei width,
+                                                           GLsizei height,
+                                                           GLboolean fixedSampleLocations,
+                                                           GLuint memory,
+                                                           GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalFormat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLboolean fixedSampleLocations = %u, GLuint memory = %u, "
+        "GLuint64 offset = %llu)",
+        target, samples, internalFormat, width, height, fixedSampleLocations, memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorageMem2DMultisampleEXT, context, targetPacked, samples, internalFormat,
+                      width, height, fixedSampleLocations, memory, offset);
+        if (context->skipValidation() || ValidateTexStorageMem2DMultisampleEXT(
+                                             context, targetPacked, samples, internalFormat, width,
+                                             height, fixedSampleLocations, memory, offset))
+        {
+            context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width,
+                                                height, fixedSampleLocations, memory, offset);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorageMem3DEXTContextANGLE(GLeglContext ctx,
+                                                GLenum target,
+                                                GLsizei levels,
+                                                GLenum internalFormat,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLsizei depth,
+                                                GLuint memory,
+                                                GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalFormat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLuint memory = %u, GLuint64 offset = %llu)",
+        target, levels, internalFormat, width, height, depth, memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorageMem3DEXT, context, targetPacked, levels, internalFormat, width,
+                      height, depth, memory, offset);
+        if (context->skipValidation() ||
+            ValidateTexStorageMem3DEXT(context, targetPacked, levels, internalFormat, width, height,
+                                       depth, memory, offset))
+        {
+            context->texStorageMem3D(targetPacked, levels, internalFormat, width, height, depth,
+                                     memory, offset);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorageMem3DMultisampleEXTContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLsizei samples,
+                                                           GLenum internalFormat,
+                                                           GLsizei width,
+                                                           GLsizei height,
+                                                           GLsizei depth,
+                                                           GLboolean fixedSampleLocations,
+                                                           GLuint memory,
+                                                           GLuint64 offset)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalFormat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLsizei depth = %d, GLboolean fixedSampleLocations = %u, "
+        "GLuint memory = %u, GLuint64 offset = %llu)",
+        target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory,
+        static_cast<unsigned long long>(offset));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorageMem3DMultisampleEXT, context, targetPacked, samples, internalFormat,
+                      width, height, depth, fixedSampleLocations, memory, offset);
+        if (context->skipValidation() || ValidateTexStorageMem3DMultisampleEXT(
+                                             context, targetPacked, samples, internalFormat, width,
+                                             height, depth, fixedSampleLocations, memory, offset))
+        {
+            context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width,
+                                                height, depth, fixedSampleLocations, memory,
+                                                offset);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage2DContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLint level,
+                                           GLint xoffset,
+                                           GLint yoffset,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLenum format,
+                                           GLenum type,
+                                           const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei "
+        "width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, const void "
+        "*pixels = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, width, height, format, type, (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage2D, context, targetPacked, level, xoffset, yoffset, width, height,
+                      format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage2D(context, targetPacked, level, xoffset, yoffset, width, height,
+                                  format, type, pixels))
+        {
+            context->texSubImage2D(targetPacked, level, xoffset, yoffset, width, height, format,
+                                   type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage3DContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLint level,
+                                           GLint xoffset,
+                                           GLint yoffset,
+                                           GLint zoffset,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth,
+                                           GLenum format,
+                                           GLenum type,
+                                           const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLenum type = 0x%X, const void *pixels = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, type,
+        (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage3D, context, targetPacked, level, xoffset, yoffset, zoffset, width,
+                      height, depth, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage3D(context, targetPacked, level, xoffset, yoffset, zoffset, width,
+                                  height, depth, format, type, pixels))
+        {
+            context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
+                                   depth, format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                              GLenum target,
+                                              GLint level,
+                                              GLint xoffset,
+                                              GLint yoffset,
+                                              GLint zoffset,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLsizei depth,
+                                              GLenum format,
+                                              GLenum type,
+                                              const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLenum type = 0x%X, const void *pixels = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, type,
+        (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage3DOES, context, targetPacked, level, xoffset, yoffset, zoffset,
+                      width, height, depth, format, type, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage3DOES(context, targetPacked, level, xoffset, yoffset, zoffset, width,
+                                     height, depth, format, type, pixels))
+        {
+            context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height,
+                                   depth, format, type, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TransformFeedbackVaryingsContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLsizei count,
+                                                       const GLchar *const *varyings,
+                                                       GLenum bufferMode)
+{
+    EVENT("(GLuint program = %u, GLsizei count = %d, const GLchar *const*varyings = 0x%016" PRIxPTR
+          ", GLenum bufferMode = 0x%X)",
+          program, count, (uintptr_t)varyings, bufferMode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(TransformFeedbackVaryings, context, program, count, varyings, bufferMode);
+        if (context->skipValidation() ||
+            ValidateTransformFeedbackVaryings(context, program, count, varyings, bufferMode))
+        {
+            context->transformFeedbackVaryings(program, count, varyings, bufferMode);
+        }
+    }
+}
+
+void GL_APIENTRY TranslatefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z)
+{
+    EVENT("(GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", x, y, z);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Translatef, context, x, y, z);
+        if (context->skipValidation() || ValidateTranslatef(context, x, y, z))
+        {
+            context->translatef(x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY TranslatexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z)
+{
+    EVENT("(GLfixed x = 0x%X, GLfixed y = 0x%X, GLfixed z = 0x%X)", x, y, z);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Translatex, context, x, y, z);
+        if (context->skipValidation() || ValidateTranslatex(context, x, y, z))
+        {
+            context->translatex(x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0)
+{
+    EVENT("(GLint location = %d, GLfloat v0 = %f)", location, v0);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform1f, context, location, v0);
+        if (context->skipValidation() || ValidateUniform1f(context, location, v0))
+        {
+            context->uniform1f(location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1fvContextANGLE(GLeglContext ctx,
+                                        GLint location,
+                                        GLsizei count,
+                                        const GLfloat *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform1fv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform1fv(context, location, count, value))
+        {
+            context->uniform1fv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1iContextANGLE(GLeglContext ctx, GLint location, GLint v0)
+{
+    EVENT("(GLint location = %d, GLint v0 = %d)", location, v0);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform1i, context, location, v0);
+        if (context->skipValidation() || ValidateUniform1i(context, location, v0))
+        {
+            context->uniform1i(location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1ivContextANGLE(GLeglContext ctx,
+                                        GLint location,
+                                        GLsizei count,
+                                        const GLint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform1iv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform1iv(context, location, count, value))
+        {
+            context->uniform1iv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0)
+{
+    EVENT("(GLint location = %d, GLuint v0 = %u)", location, v0);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform1ui, context, location, v0);
+        if (context->skipValidation() || ValidateUniform1ui(context, location, v0))
+        {
+            context->uniform1ui(location, v0);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform1uivContextANGLE(GLeglContext ctx,
+                                         GLint location,
+                                         GLsizei count,
+                                         const GLuint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform1uiv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform1uiv(context, location, count, value))
+        {
+            context->uniform1uiv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1)
+{
+    EVENT("(GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f)", location, v0, v1);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform2f, context, location, v0, v1);
+        if (context->skipValidation() || ValidateUniform2f(context, location, v0, v1))
+        {
+            context->uniform2f(location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2fvContextANGLE(GLeglContext ctx,
+                                        GLint location,
+                                        GLsizei count,
+                                        const GLfloat *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform2fv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform2fv(context, location, count, value))
+        {
+            context->uniform2fv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1)
+{
+    EVENT("(GLint location = %d, GLint v0 = %d, GLint v1 = %d)", location, v0, v1);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform2i, context, location, v0, v1);
+        if (context->skipValidation() || ValidateUniform2i(context, location, v0, v1))
+        {
+            context->uniform2i(location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2ivContextANGLE(GLeglContext ctx,
+                                        GLint location,
+                                        GLsizei count,
+                                        const GLint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform2iv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform2iv(context, location, count, value))
+        {
+            context->uniform2iv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1)
+{
+    EVENT("(GLint location = %d, GLuint v0 = %u, GLuint v1 = %u)", location, v0, v1);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform2ui, context, location, v0, v1);
+        if (context->skipValidation() || ValidateUniform2ui(context, location, v0, v1))
+        {
+            context->uniform2ui(location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform2uivContextANGLE(GLeglContext ctx,
+                                         GLint location,
+                                         GLsizei count,
+                                         const GLuint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform2uiv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform2uiv(context, location, count, value))
+        {
+            context->uniform2uiv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+Uniform3fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+{
+    EVENT("(GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = %f)", location, v0,
+          v1, v2);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform3f, context, location, v0, v1, v2);
+        if (context->skipValidation() || ValidateUniform3f(context, location, v0, v1, v2))
+        {
+            context->uniform3f(location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3fvContextANGLE(GLeglContext ctx,
+                                        GLint location,
+                                        GLsizei count,
+                                        const GLfloat *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform3fv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform3fv(context, location, count, value))
+        {
+            context->uniform3fv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+Uniform3iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2)
+{
+    EVENT("(GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d)", location, v0, v1,
+          v2);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform3i, context, location, v0, v1, v2);
+        if (context->skipValidation() || ValidateUniform3i(context, location, v0, v1, v2))
+        {
+            context->uniform3i(location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3ivContextANGLE(GLeglContext ctx,
+                                        GLint location,
+                                        GLsizei count,
+                                        const GLint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform3iv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform3iv(context, location, count, value))
+        {
+            context->uniform3iv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+Uniform3uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2)
+{
+    EVENT("(GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = %u)", location, v0, v1,
+          v2);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform3ui, context, location, v0, v1, v2);
+        if (context->skipValidation() || ValidateUniform3ui(context, location, v0, v1, v2))
+        {
+            context->uniform3ui(location, v0, v1, v2);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform3uivContextANGLE(GLeglContext ctx,
+                                         GLint location,
+                                         GLsizei count,
+                                         const GLuint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform3uiv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform3uiv(context, location, count, value))
+        {
+            context->uniform3uiv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4fContextANGLE(GLeglContext ctx,
+                                       GLint location,
+                                       GLfloat v0,
+                                       GLfloat v1,
+                                       GLfloat v2,
+                                       GLfloat v3)
+{
+    EVENT(
+        "(GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = %f, GLfloat v3 = %f)",
+        location, v0, v1, v2, v3);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform4f, context, location, v0, v1, v2, v3);
+        if (context->skipValidation() || ValidateUniform4f(context, location, v0, v1, v2, v3))
+        {
+            context->uniform4f(location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4fvContextANGLE(GLeglContext ctx,
+                                        GLint location,
+                                        GLsizei count,
+                                        const GLfloat *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform4fv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform4fv(context, location, count, value))
+        {
+            context->uniform4fv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+Uniform4iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+{
+    EVENT("(GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, GLint v3 = %d)",
+          location, v0, v1, v2, v3);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform4i, context, location, v0, v1, v2, v3);
+        if (context->skipValidation() || ValidateUniform4i(context, location, v0, v1, v2, v3))
+        {
+            context->uniform4i(location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4ivContextANGLE(GLeglContext ctx,
+                                        GLint location,
+                                        GLsizei count,
+                                        const GLint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform4iv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform4iv(context, location, count, value))
+        {
+            context->uniform4iv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY
+Uniform4uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+{
+    EVENT("(GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = %u, GLuint v3 = %u)",
+          location, v0, v1, v2, v3);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform4ui, context, location, v0, v1, v2, v3);
+        if (context->skipValidation() || ValidateUniform4ui(context, location, v0, v1, v2, v3))
+        {
+            context->uniform4ui(location, v0, v1, v2, v3);
+        }
+    }
+}
+
+void GL_APIENTRY Uniform4uivContextANGLE(GLeglContext ctx,
+                                         GLint location,
+                                         GLsizei count,
+                                         const GLuint *value)
+{
+    EVENT("(GLint location = %d, GLsizei count = %d, const GLuint *value = 0x%016" PRIxPTR ")",
+          location, count, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Uniform4uiv, context, location, count, value);
+        if (context->skipValidation() || ValidateUniform4uiv(context, location, count, value))
+        {
+            context->uniform4uiv(location, count, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformBlockBindingContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLuint uniformBlockIndex,
+                                                 GLuint uniformBlockBinding)
+{
+    EVENT("(GLuint program = %u, GLuint uniformBlockIndex = %u, GLuint uniformBlockBinding = %u)",
+          program, uniformBlockIndex, uniformBlockBinding);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformBlockBinding, context, program, uniformBlockIndex,
+                      uniformBlockBinding);
+        if (context->skipValidation() ||
+            ValidateUniformBlockBinding(context, program, uniformBlockIndex, uniformBlockBinding))
+        {
+            context->uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix2fvContextANGLE(GLeglContext ctx,
+                                              GLint location,
+                                              GLsizei count,
+                                              GLboolean transpose,
+                                              const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix2fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix2fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix2fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix2x3fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix2x3fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix2x3fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix2x3fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix2x4fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix2x4fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix2x4fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix2x4fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix3fvContextANGLE(GLeglContext ctx,
+                                              GLint location,
+                                              GLsizei count,
+                                              GLboolean transpose,
+                                              const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix3fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix3fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix3fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix3x2fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix3x2fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix3x2fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix3x2fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix3x4fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix3x4fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix3x4fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix3x4fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix4fvContextANGLE(GLeglContext ctx,
+                                              GLint location,
+                                              GLsizei count,
+                                              GLboolean transpose,
+                                              const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix4fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix4fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix4fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix4x2fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix4x2fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix4x2fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix4x2fv(location, count, transpose, value);
+        }
+    }
+}
+
+void GL_APIENTRY UniformMatrix4x3fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    EVENT(
+        "(GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, const GLfloat *value "
+        "= 0x%016" PRIxPTR ")",
+        location, count, transpose, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UniformMatrix4x3fv, context, location, count, transpose, value);
+        if (context->skipValidation() ||
+            ValidateUniformMatrix4x3fv(context, location, count, transpose, value))
+        {
+            context->uniformMatrix4x3fv(location, count, transpose, value);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY UnmapBufferContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(UnmapBuffer, context, targetPacked);
+        if (context->skipValidation() || ValidateUnmapBuffer(context, targetPacked))
+        {
+            return context->unmapBuffer(targetPacked);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::UnmapBuffer, GLboolean>();
+}
+
+GLboolean GL_APIENTRY UnmapBufferOESContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(UnmapBufferOES, context, targetPacked);
+        if (context->skipValidation() || ValidateUnmapBufferOES(context, targetPacked))
+        {
+            return context->unmapBuffer(targetPacked);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::UnmapBufferOES, GLboolean>();
+}
+
+void GL_APIENTRY UseProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UseProgram, context, program);
+        if (context->skipValidation() || ValidateUseProgram(context, program))
+        {
+            context->useProgram(program);
+        }
+    }
+}
+
+void GL_APIENTRY UseProgramStagesContextANGLE(GLeglContext ctx,
+                                              GLuint pipeline,
+                                              GLbitfield stages,
+                                              GLuint program)
+{
+    EVENT("(GLuint pipeline = %u, GLbitfield stages = 0x%X, GLuint program = %u)", pipeline, stages,
+          program);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(UseProgramStages, context, pipeline, stages, program);
+        if (context->skipValidation() ||
+            ValidateUseProgramStages(context, pipeline, stages, program))
+        {
+            context->useProgramStages(pipeline, stages, program);
+        }
+    }
+}
+
+void GL_APIENTRY ValidateProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    EVENT("(GLuint program = %u)", program);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ValidateProgram, context, program);
+        if (context->skipValidation() || ValidateValidateProgram(context, program))
+        {
+            context->validateProgram(program);
+        }
+    }
+}
+
+void GL_APIENTRY ValidateProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
+{
+    EVENT("(GLuint pipeline = %u)", pipeline);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ValidateProgramPipeline, context, pipeline);
+        if (context->skipValidation() || ValidateValidateProgramPipeline(context, pipeline))
+        {
+            context->validateProgramPipeline(pipeline);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib1fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x)
+{
+    EVENT("(GLuint index = %u, GLfloat x = %f)", index, x);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttrib1f, context, index, x);
+        if (context->skipValidation() || ValidateVertexAttrib1f(context, index, x))
+        {
+            context->vertexAttrib1f(index, x);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib1fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
+{
+    EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttrib1fv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttrib1fv(context, index, v))
+        {
+            context->vertexAttrib1fv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib2fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y)
+{
+    EVENT("(GLuint index = %u, GLfloat x = %f, GLfloat y = %f)", index, x, y);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttrib2f, context, index, x, y);
+        if (context->skipValidation() || ValidateVertexAttrib2f(context, index, x, y))
+        {
+            context->vertexAttrib2f(index, x, y);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib2fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
+{
+    EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttrib2fv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttrib2fv(context, index, v))
+        {
+            context->vertexAttrib2fv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY
+VertexAttrib3fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+    EVENT("(GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", index, x, y, z);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttrib3f, context, index, x, y, z);
+        if (context->skipValidation() || ValidateVertexAttrib3f(context, index, x, y, z))
+        {
+            context->vertexAttrib3f(index, x, y, z);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib3fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
+{
+    EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttrib3fv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttrib3fv(context, index, v))
+        {
+            context->vertexAttrib3fv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib4fContextANGLE(GLeglContext ctx,
+                                            GLuint index,
+                                            GLfloat x,
+                                            GLfloat y,
+                                            GLfloat z,
+                                            GLfloat w)
+{
+    EVENT("(GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)",
+          index, x, y, z, w);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttrib4f, context, index, x, y, z, w);
+        if (context->skipValidation() || ValidateVertexAttrib4f(context, index, x, y, z, w))
+        {
+            context->vertexAttrib4f(index, x, y, z, w);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttrib4fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
+{
+    EVENT("(GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttrib4fv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttrib4fv(context, index, v))
+        {
+            context->vertexAttrib4fv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribBindingContextANGLE(GLeglContext ctx,
+                                                 GLuint attribindex,
+                                                 GLuint bindingindex)
+{
+    EVENT("(GLuint attribindex = %u, GLuint bindingindex = %u)", attribindex, bindingindex);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttribBinding, context, attribindex, bindingindex);
+        if (context->skipValidation() ||
+            ValidateVertexAttribBinding(context, attribindex, bindingindex))
+        {
+            context->vertexAttribBinding(attribindex, bindingindex);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribDivisorContextANGLE(GLeglContext ctx, GLuint index, GLuint divisor)
+{
+    EVENT("(GLuint index = %u, GLuint divisor = %u)", index, divisor);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttribDivisor, context, index, divisor);
+        if (context->skipValidation() || ValidateVertexAttribDivisor(context, index, divisor))
+        {
+            context->vertexAttribDivisor(index, divisor);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribDivisorANGLEContextANGLE(GLeglContext ctx,
+                                                      GLuint index,
+                                                      GLuint divisor)
+{
+    EVENT("(GLuint index = %u, GLuint divisor = %u)", index, divisor);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttribDivisorANGLE, context, index, divisor);
+        if (context->skipValidation() || ValidateVertexAttribDivisorANGLE(context, index, divisor))
+        {
+            context->vertexAttribDivisor(index, divisor);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribDivisorEXTContextANGLE(GLeglContext ctx, GLuint index, GLuint divisor)
+{
+    EVENT("(GLuint index = %u, GLuint divisor = %u)", index, divisor);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttribDivisorEXT, context, index, divisor);
+        if (context->skipValidation() || ValidateVertexAttribDivisorEXT(context, index, divisor))
+        {
+            context->vertexAttribDivisor(index, divisor);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribFormatContextANGLE(GLeglContext ctx,
+                                                GLuint attribindex,
+                                                GLint size,
+                                                GLenum type,
+                                                GLboolean normalized,
+                                                GLuint relativeoffset)
+{
+    EVENT(
+        "(GLuint attribindex = %u, GLint size = %d, GLenum type = 0x%X, GLboolean normalized = %u, "
+        "GLuint relativeoffset = %u)",
+        attribindex, size, type, normalized, relativeoffset);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexAttribFormat, context, attribindex, size, typePacked, normalized,
+                      relativeoffset);
+        if (context->skipValidation() ||
+            ValidateVertexAttribFormat(context, attribindex, size, typePacked, normalized,
+                                       relativeoffset))
+        {
+            context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset);
+        }
+    }
+}
+
+void GL_APIENTRY
+VertexAttribI4iContextANGLE(GLeglContext ctx, GLuint index, GLint x, GLint y, GLint z, GLint w)
+{
+    EVENT("(GLuint index = %u, GLint x = %d, GLint y = %d, GLint z = %d, GLint w = %d)", index, x,
+          y, z, w);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttribI4i, context, index, x, y, z, w);
+        if (context->skipValidation() || ValidateVertexAttribI4i(context, index, x, y, z, w))
+        {
+            context->vertexAttribI4i(index, x, y, z, w);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribI4ivContextANGLE(GLeglContext ctx, GLuint index, const GLint *v)
+{
+    EVENT("(GLuint index = %u, const GLint *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttribI4iv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttribI4iv(context, index, v))
+        {
+            context->vertexAttribI4iv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY
+VertexAttribI4uiContextANGLE(GLeglContext ctx, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+{
+    EVENT("(GLuint index = %u, GLuint x = %u, GLuint y = %u, GLuint z = %u, GLuint w = %u)", index,
+          x, y, z, w);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttribI4ui, context, index, x, y, z, w);
+        if (context->skipValidation() || ValidateVertexAttribI4ui(context, index, x, y, z, w))
+        {
+            context->vertexAttribI4ui(index, x, y, z, w);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribI4uivContextANGLE(GLeglContext ctx, GLuint index, const GLuint *v)
+{
+    EVENT("(GLuint index = %u, const GLuint *v = 0x%016" PRIxPTR ")", index, (uintptr_t)v);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexAttribI4uiv, context, index, v);
+        if (context->skipValidation() || ValidateVertexAttribI4uiv(context, index, v))
+        {
+            context->vertexAttribI4uiv(index, v);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribIFormatContextANGLE(GLeglContext ctx,
+                                                 GLuint attribindex,
+                                                 GLint size,
+                                                 GLenum type,
+                                                 GLuint relativeoffset)
+{
+    EVENT(
+        "(GLuint attribindex = %u, GLint size = %d, GLenum type = 0x%X, GLuint relativeoffset = "
+        "%u)",
+        attribindex, size, type, relativeoffset);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexAttribIFormat, context, attribindex, size, typePacked, relativeoffset);
+        if (context->skipValidation() ||
+            ValidateVertexAttribIFormat(context, attribindex, size, typePacked, relativeoffset))
+        {
+            context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribIPointerContextANGLE(GLeglContext ctx,
+                                                  GLuint index,
+                                                  GLint size,
+                                                  GLenum type,
+                                                  GLsizei stride,
+                                                  const void *pointer)
+{
+    EVENT(
+        "(GLuint index = %u, GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void "
+        "*pointer = 0x%016" PRIxPTR ")",
+        index, size, type, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexAttribIPointer, context, index, size, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateVertexAttribIPointer(context, index, size, typePacked, stride, pointer))
+        {
+            context->vertexAttribIPointer(index, size, typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY VertexAttribPointerContextANGLE(GLeglContext ctx,
+                                                 GLuint index,
+                                                 GLint size,
+                                                 GLenum type,
+                                                 GLboolean normalized,
+                                                 GLsizei stride,
+                                                 const void *pointer)
+{
+    EVENT(
+        "(GLuint index = %u, GLint size = %d, GLenum type = 0x%X, GLboolean normalized = %u, "
+        "GLsizei stride = %d, const void *pointer = 0x%016" PRIxPTR ")",
+        index, size, type, normalized, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexAttribPointer, context, index, size, typePacked, normalized, stride,
+                      pointer);
+        if (context->skipValidation() ||
+            ValidateVertexAttribPointer(context, index, size, typePacked, normalized, stride,
+                                        pointer))
+        {
+            context->vertexAttribPointer(index, size, typePacked, normalized, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY VertexBindingDivisorContextANGLE(GLeglContext ctx,
+                                                  GLuint bindingindex,
+                                                  GLuint divisor)
+{
+    EVENT("(GLuint bindingindex = %u, GLuint divisor = %u)", bindingindex, divisor);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(VertexBindingDivisor, context, bindingindex, divisor);
+        if (context->skipValidation() ||
+            ValidateVertexBindingDivisor(context, bindingindex, divisor))
+        {
+            context->vertexBindingDivisor(bindingindex, divisor);
+        }
+    }
+}
+
+void GL_APIENTRY VertexPointerContextANGLE(GLeglContext ctx,
+                                           GLint size,
+                                           GLenum type,
+                                           GLsizei stride,
+                                           const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        VertexAttribType typePacked = FromGLenum<VertexAttribType>(type);
+        ANGLE_CAPTURE(VertexPointer, context, size, typePacked, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateVertexPointer(context, size, typePacked, stride, pointer))
+        {
+            context->vertexPointer(size, typePacked, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY
+ViewportContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width,
+          height);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(Viewport, context, x, y, width, height);
+        if (context->skipValidation() || ValidateViewport(context, x, y, width, height))
+        {
+            context->viewport(x, y, width, height);
+        }
+    }
+}
+
+void GL_APIENTRY WaitSemaphoreEXTContextANGLE(GLeglContext ctx,
+                                              GLuint semaphore,
+                                              GLuint numBufferBarriers,
+                                              const GLuint *buffers,
+                                              GLuint numTextureBarriers,
+                                              const GLuint *textures,
+                                              const GLenum *srcLayouts)
+{
+    EVENT(
+        "(GLuint semaphore = %u, GLuint numBufferBarriers = %u, const GLuint *buffers = "
+        "0x%016" PRIxPTR ", GLuint numTextureBarriers = %u, const GLuint *textures = 0x%016" PRIxPTR
+        ", const GLenum *srcLayouts = 0x%016" PRIxPTR ")",
+        semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers, (uintptr_t)textures,
+        (uintptr_t)srcLayouts);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(WaitSemaphoreEXT, context, semaphore, numBufferBarriers, buffers,
+                      numTextureBarriers, textures, srcLayouts);
+        if (context->skipValidation() ||
+            ValidateWaitSemaphoreEXT(context, semaphore, numBufferBarriers, buffers,
+                                     numTextureBarriers, textures, srcLayouts))
+        {
+            context->waitSemaphore(semaphore, numBufferBarriers, buffers, numTextureBarriers,
+                                   textures, srcLayouts);
+        }
+    }
+}
+
+void GL_APIENTRY WaitSyncContextANGLE(GLeglContext ctx,
+                                      GLsync sync,
+                                      GLbitfield flags,
+                                      GLuint64 timeout)
+{
+    EVENT("(GLsync sync = 0x%016" PRIxPTR ", GLbitfield flags = 0x%X, GLuint64 timeout = %llu)",
+          (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout));
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(WaitSync, context, sync, flags, timeout);
+        if (context->skipValidation() || ValidateWaitSync(context, sync, flags, timeout))
+        {
+            context->waitSync(sync, flags, timeout);
+        }
+    }
+}
+
+void GL_APIENTRY WeightPointerOESContextANGLE(GLeglContext ctx,
+                                              GLint size,
+                                              GLenum type,
+                                              GLsizei stride,
+                                              const void *pointer)
+{
+    EVENT(
+        "(GLint size = %d, GLenum type = 0x%X, GLsizei stride = %d, const void *pointer = "
+        "0x%016" PRIxPTR ")",
+        size, type, stride, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(WeightPointerOES, context, size, type, stride, pointer);
+        if (context->skipValidation() ||
+            ValidateWeightPointerOES(context, size, type, stride, pointer))
+        {
+            context->weightPointer(size, type, stride, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY BindUniformLocationCHROMIUMContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLint location,
+                                                         const GLchar *name)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, const GLchar* name = 0x%016" PRIxPTR ")",
+          program, location, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindUniformLocationCHROMIUM, context, program, location, name);
+        if (context->skipValidation() ||
+            ValidateBindUniformLocationCHROMIUM(context, program, location, name))
+        {
+            context->bindUniformLocation(program, location, name);
+        }
+    }
+}
+
+void GL_APIENTRY CoverageModulationCHROMIUMContextANGLE(GLeglContext ctx, GLenum components)
+{
+    EVENT("(GLenum components = 0x%X)", components);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CoverageModulationCHROMIUM, context, components);
+        if (context->skipValidation() || ValidateCoverageModulationCHROMIUM(context, components))
+        {
+            context->coverageModulation(components);
+        }
+    }
+}
+
+void GL_APIENTRY MatrixLoadfCHROMIUMContextANGLE(GLeglContext ctx,
+                                                 GLenum matrixMode,
+                                                 const GLfloat *matrix)
+{
+    EVENT("(GLenum matrixMode = 0x%X, const GLfloat * matrix = 0x%016" PRIxPTR ")", matrixMode,
+          (uintptr_t)matrix);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MatrixLoadfCHROMIUM, context, matrixMode, matrix);
+        if (context->skipValidation() || ValidateMatrixLoadfCHROMIUM(context, matrixMode, matrix))
+        {
+            context->matrixLoadf(matrixMode, matrix);
+        }
+    }
+}
+
+void GL_APIENTRY MatrixLoadIdentityCHROMIUMContextANGLE(GLeglContext ctx, GLenum matrixMode)
+{
+    EVENT("(GLenum matrixMode = 0x%X)", matrixMode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(MatrixLoadIdentityCHROMIUM, context, matrixMode);
+        if (context->skipValidation() || ValidateMatrixLoadIdentityCHROMIUM(context, matrixMode))
+        {
+            context->matrixLoadIdentity(matrixMode);
+        }
+    }
+}
+
+GLuint GL_APIENTRY GenPathsCHROMIUMContextANGLE(GLeglContext ctx, GLsizei range)
+{
+    EVENT("(GLsizei range = %d)", range);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GenPathsCHROMIUM, context, range);
+        if (context->skipValidation() || ValidateGenPathsCHROMIUM(context, range))
+        {
+            return context->genPaths(range);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GenPathsCHROMIUM, GLuint>();
+}
+
+void GL_APIENTRY DeletePathsCHROMIUMContextANGLE(GLeglContext ctx, GLuint first, GLsizei range)
+{
+    EVENT("(GLuint first = %u, GLsizei range = %d)", first, range);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(DeletePathsCHROMIUM, context, first, range);
+        if (context->skipValidation() || ValidateDeletePathsCHROMIUM(context, first, range))
+        {
+            context->deletePaths(first, range);
+        }
+    }
+}
+
+GLboolean GL_APIENTRY IsPathCHROMIUMContextANGLE(GLeglContext ctx, GLuint path)
+{
+    EVENT("(GLuint path = %u)", path);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(IsPathCHROMIUM, context, path);
+        if (context->skipValidation() || ValidateIsPathCHROMIUM(context, path))
+        {
+            return context->isPath(path);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::IsPathCHROMIUM, GLboolean>();
+}
+
+void GL_APIENTRY PathCommandsCHROMIUMContextANGLE(GLeglContext ctx,
+                                                  GLuint path,
+                                                  GLsizei numCommands,
+                                                  const GLubyte *commands,
+                                                  GLsizei numCoords,
+                                                  GLenum coordType,
+                                                  const void *coords)
+{
+    EVENT("(GLuint path = %u, GLsizei numCommands = %d, const GLubyte * commands = 0x%016" PRIxPTR
+          ", GLsizei numCoords = %d, GLenum coordType = 0x%X, const void* coords = 0x%016" PRIxPTR
+          ")",
+          path, numCommands, (uintptr_t)commands, numCoords, coordType, (uintptr_t)coords);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PathCommandsCHROMIUM, context, path, numCommands, commands, numCoords,
+                      coordType, coords);
+        if (context->skipValidation() ||
+            ValidatePathCommandsCHROMIUM(context, path, numCommands, commands, numCoords, coordType,
+                                         coords))
+        {
+            context->pathCommands(path, numCommands, commands, numCoords, coordType, coords);
+        }
+    }
+}
+
+void GL_APIENTRY PathParameterfCHROMIUMContextANGLE(GLeglContext ctx,
+                                                    GLuint path,
+                                                    GLenum pname,
+                                                    GLfloat value)
+{
+    EVENT("(GLuint path = %u, GLenum pname = 0x%X, GLfloat value = %f)", path, pname, value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PathParameterfCHROMIUM, context, path, pname, value);
+        if (context->skipValidation() ||
+            ValidatePathParameterfCHROMIUM(context, path, pname, value))
+        {
+            context->pathParameterf(path, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY PathParameteriCHROMIUMContextANGLE(GLeglContext ctx,
+                                                    GLuint path,
+                                                    GLenum pname,
+                                                    GLint value)
+{
+    EVENT("(GLuint path = %u, GLenum pname = 0x%X, GLint value = %d)", path, pname, value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PathParameteriCHROMIUM, context, path, pname, value);
+        if (context->skipValidation() ||
+            ValidatePathParameteriCHROMIUM(context, path, pname, value))
+        {
+            context->pathParameteri(path, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY GetPathParameterfvCHROMIUMContextANGLE(GLeglContext ctx,
+                                                        GLuint path,
+                                                        GLenum pname,
+                                                        GLfloat *value)
+{
+    EVENT("(GLuint path = %u, GLenum pname = 0x%X, GLfloat * value = 0x%016" PRIxPTR ")", path,
+          pname, (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetPathParameterfvCHROMIUM, context, path, pname, value);
+        if (context->skipValidation() ||
+            ValidateGetPathParameterfvCHROMIUM(context, path, pname, value))
+        {
+            context->getPathParameterfv(path, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY GetPathParameterivCHROMIUMContextANGLE(GLeglContext ctx,
+                                                        GLuint path,
+                                                        GLenum pname,
+                                                        GLint *value)
+{
+    EVENT("(GLuint path = %u, GLenum pname = 0x%X, GLint * value = 0x%016" PRIxPTR ")", path, pname,
+          (uintptr_t)value);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetPathParameterivCHROMIUM, context, path, pname, value);
+        if (context->skipValidation() ||
+            ValidateGetPathParameterivCHROMIUM(context, path, pname, value))
+        {
+            context->getPathParameteriv(path, pname, value);
+        }
+    }
+}
+
+void GL_APIENTRY PathStencilFuncCHROMIUMContextANGLE(GLeglContext ctx,
+                                                     GLenum func,
+                                                     GLint ref,
+                                                     GLuint mask)
+{
+    EVENT("(GLenum func = 0x%X, GLint ref = %d, GLuint mask = %u)", func, ref, mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(PathStencilFuncCHROMIUM, context, func, ref, mask);
+        if (context->skipValidation() || ValidatePathStencilFuncCHROMIUM(context, func, ref, mask))
+        {
+            context->pathStencilFunc(func, ref, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilFillPathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                     GLuint path,
+                                                     GLenum fillMode,
+                                                     GLuint mask)
+{
+    EVENT("(GLuint path = %u, GLenum fillMode = 0x%X, GLuint mask = %u)", path, fillMode, mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilFillPathCHROMIUM, context, path, fillMode, mask);
+        if (context->skipValidation() ||
+            ValidateStencilFillPathCHROMIUM(context, path, fillMode, mask))
+        {
+            context->stencilFillPath(path, fillMode, mask);
+        }
+    }
+}
+
+void GL_APIENTRY StencilStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                       GLuint path,
+                                                       GLint reference,
+                                                       GLuint mask)
+{
+    EVENT("(GLuint path = %u, GLint reference = %d, GLuint mask = %u)", path, reference, mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilStrokePathCHROMIUM, context, path, reference, mask);
+        if (context->skipValidation() ||
+            ValidateStencilStrokePathCHROMIUM(context, path, reference, mask))
+        {
+            context->stencilStrokePath(path, reference, mask);
+        }
+    }
+}
+
+void GL_APIENTRY CoverFillPathCHROMIUMContextANGLE(GLeglContext ctx, GLuint path, GLenum coverMode)
+{
+    EVENT("(GLuint path = %u, GLenum coverMode = 0x%X)", path, coverMode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CoverFillPathCHROMIUM, context, path, coverMode);
+        if (context->skipValidation() || ValidateCoverFillPathCHROMIUM(context, path, coverMode))
+        {
+            context->coverFillPath(path, coverMode);
+        }
+    }
+}
+
+void GL_APIENTRY CoverStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                     GLuint path,
+                                                     GLenum coverMode)
+{
+    EVENT("(GLuint path = %u, GLenum coverMode = 0x%X)", path, coverMode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CoverStrokePathCHROMIUM, context, path, coverMode);
+        if (context->skipValidation() || ValidateCoverStrokePathCHROMIUM(context, path, coverMode))
+        {
+            context->coverStrokePath(path, coverMode);
+        }
+    }
+}
+
+void GL_APIENTRY StencilThenCoverFillPathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                              GLuint path,
+                                                              GLenum fillMode,
+                                                              GLuint mask,
+                                                              GLenum coverMode)
+{
+    EVENT("(GLuint path = %u, GLenum fillMode = 0x%X, GLuint mask = %u, GLenum coverMode = 0x%X)",
+          path, fillMode, mask, coverMode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilThenCoverFillPathCHROMIUM, context, path, fillMode, mask, coverMode);
+        if (context->skipValidation() ||
+            ValidateStencilThenCoverFillPathCHROMIUM(context, path, fillMode, mask, coverMode))
+        {
+            context->stencilThenCoverFillPath(path, fillMode, mask, coverMode);
+        }
+    }
+}
+
+void GL_APIENTRY StencilThenCoverStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                GLuint path,
+                                                                GLint reference,
+                                                                GLuint mask,
+                                                                GLenum coverMode)
+{
+    EVENT("(GLuint path = %u, GLint reference = %d, GLuint mask = %u, GLenum coverMode = 0x%X)",
+          path, reference, mask, coverMode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilThenCoverStrokePathCHROMIUM, context, path, reference, mask,
+                      coverMode);
+        if (context->skipValidation() ||
+            ValidateStencilThenCoverStrokePathCHROMIUM(context, path, reference, mask, coverMode))
+        {
+            context->stencilThenCoverStrokePath(path, reference, mask, coverMode);
+        }
+    }
+}
+
+void GL_APIENTRY CoverFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                            GLsizei numPath,
+                                                            GLenum pathNameType,
+                                                            const void *paths,
+                                                            GLuint pathBase,
+                                                            GLenum coverMode,
+                                                            GLenum transformType,
+                                                            const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPath = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLenum coverMode = 0x%X, GLenum transformType = 0x%X, const "
+          "GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPath, pathNameType, (uintptr_t)paths, pathBase, coverMode, transformType,
+          (uintptr_t)transformValues);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CoverFillPathInstancedCHROMIUM, context, numPath, pathNameType, paths,
+                      pathBase, coverMode, transformType, transformValues);
+        if (context->skipValidation() ||
+            ValidateCoverFillPathInstancedCHROMIUM(context, numPath, pathNameType, paths, pathBase,
+                                                   coverMode, transformType, transformValues))
+        {
+            context->coverFillPathInstanced(numPath, pathNameType, paths, pathBase, coverMode,
+                                            transformType, transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY CoverStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                              GLsizei numPath,
+                                                              GLenum pathNameType,
+                                                              const void *paths,
+                                                              GLuint pathBase,
+                                                              GLenum coverMode,
+                                                              GLenum transformType,
+                                                              const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPath = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLenum coverMode = 0x%X, GLenum transformType = 0x%X, const "
+          "GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPath, pathNameType, (uintptr_t)paths, pathBase, coverMode, transformType,
+          (uintptr_t)transformValues);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CoverStrokePathInstancedCHROMIUM, context, numPath, pathNameType, paths,
+                      pathBase, coverMode, transformType, transformValues);
+        if (context->skipValidation() || ValidateCoverStrokePathInstancedCHROMIUM(
+                                             context, numPath, pathNameType, paths, pathBase,
+                                             coverMode, transformType, transformValues))
+        {
+            context->coverStrokePathInstanced(numPath, pathNameType, paths, pathBase, coverMode,
+                                              transformType, transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY StencilStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                GLsizei numPath,
+                                                                GLenum pathNameType,
+                                                                const void *paths,
+                                                                GLuint pathBase,
+                                                                GLint reference,
+                                                                GLuint mask,
+                                                                GLenum transformType,
+                                                                const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPath = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLint reference = %d, GLuint mask = %u, GLenum transformType = "
+          "0x%X, const GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPath, pathNameType, (uintptr_t)paths, pathBase, reference, mask, transformType,
+          (uintptr_t)transformValues);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilStrokePathInstancedCHROMIUM, context, numPath, pathNameType, paths,
+                      pathBase, reference, mask, transformType, transformValues);
+        if (context->skipValidation() || ValidateStencilStrokePathInstancedCHROMIUM(
+                                             context, numPath, pathNameType, paths, pathBase,
+                                             reference, mask, transformType, transformValues))
+        {
+            context->stencilStrokePathInstanced(numPath, pathNameType, paths, pathBase, reference,
+                                                mask, transformType, transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY StencilFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                              GLsizei numPaths,
+                                                              GLenum pathNameType,
+                                                              const void *paths,
+                                                              GLuint pathBase,
+                                                              GLenum fillMode,
+                                                              GLuint mask,
+                                                              GLenum transformType,
+                                                              const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPaths = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLenum fillMode = 0x%X, GLuint mask = %u, GLenum transformType "
+          "= 0x%X, const GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPaths, pathNameType, (uintptr_t)paths, pathBase, fillMode, mask, transformType,
+          (uintptr_t)transformValues);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilFillPathInstancedCHROMIUM, context, numPaths, pathNameType, paths,
+                      pathBase, fillMode, mask, transformType, transformValues);
+        if (context->skipValidation() || ValidateStencilFillPathInstancedCHROMIUM(
+                                             context, numPaths, pathNameType, paths, pathBase,
+                                             fillMode, mask, transformType, transformValues))
+        {
+            context->stencilFillPathInstanced(numPaths, pathNameType, paths, pathBase, fillMode,
+                                              mask, transformType, transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY
+StencilThenCoverFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                      GLsizei numPaths,
+                                                      GLenum pathNameType,
+                                                      const void *paths,
+                                                      GLuint pathBase,
+                                                      GLenum fillMode,
+                                                      GLuint mask,
+                                                      GLenum coverMode,
+                                                      GLenum transformType,
+                                                      const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPaths = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLenum fillMode = 0x%X, GLuint mask = %u, GLenum coverMode = "
+          "0x%X, GLenum transformType = 0x%X, const GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPaths, pathNameType, (uintptr_t)paths, pathBase, fillMode, mask, coverMode,
+          transformType, (uintptr_t)transformValues);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilThenCoverFillPathInstancedCHROMIUM, context, numPaths, pathNameType,
+                      paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
+        if (context->skipValidation() ||
+            ValidateStencilThenCoverFillPathInstancedCHROMIUM(
+                context, numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+                transformType, transformValues))
+        {
+            context->stencilThenCoverFillPathInstanced(numPaths, pathNameType, paths, pathBase,
+                                                       fillMode, mask, coverMode, transformType,
+                                                       transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY
+StencilThenCoverStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                        GLsizei numPaths,
+                                                        GLenum pathNameType,
+                                                        const void *paths,
+                                                        GLuint pathBase,
+                                                        GLint reference,
+                                                        GLuint mask,
+                                                        GLenum coverMode,
+                                                        GLenum transformType,
+                                                        const GLfloat *transformValues)
+{
+    EVENT("(GLsizei numPaths = %d, GLenum pathNameType = 0x%X, const void * paths = 0x%016" PRIxPTR
+          ", GLuint pathBase = %u, GLint reference = %d, GLuint mask = %u, GLenum coverMode = "
+          "0x%X, GLenum transformType = 0x%X, const GLfloat * transformValues = 0x%016" PRIxPTR ")",
+          numPaths, pathNameType, (uintptr_t)paths, pathBase, reference, mask, coverMode,
+          transformType, (uintptr_t)transformValues);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(StencilThenCoverStrokePathInstancedCHROMIUM, context, numPaths, pathNameType,
+                      paths, pathBase, reference, mask, coverMode, transformType, transformValues);
+        if (context->skipValidation() ||
+            ValidateStencilThenCoverStrokePathInstancedCHROMIUM(
+                context, numPaths, pathNameType, paths, pathBase, reference, mask, coverMode,
+                transformType, transformValues))
+        {
+            context->stencilThenCoverStrokePathInstanced(numPaths, pathNameType, paths, pathBase,
+                                                         reference, mask, coverMode, transformType,
+                                                         transformValues);
+        }
+    }
+}
+
+void GL_APIENTRY BindFragmentInputLocationCHROMIUMContextANGLE(GLeglContext ctx,
+                                                               GLuint programs,
+                                                               GLint location,
+                                                               const GLchar *name)
+{
+    EVENT("(GLuint programs = %u, GLint location = %d, const GLchar * name = 0x%016" PRIxPTR ")",
+          programs, location, (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(BindFragmentInputLocationCHROMIUM, context, programs, location, name);
+        if (context->skipValidation() ||
+            ValidateBindFragmentInputLocationCHROMIUM(context, programs, location, name))
+        {
+            context->bindFragmentInputLocation(programs, location, name);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramPathFragmentInputGenCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                 GLuint program,
+                                                                 GLint location,
+                                                                 GLenum genMode,
+                                                                 GLint components,
+                                                                 const GLfloat *coeffs)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLenum genMode = 0x%X, GLint components = %d, "
+        "const GLfloat * coeffs = 0x%016" PRIxPTR ")",
+        program, location, genMode, components, (uintptr_t)coeffs);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ProgramPathFragmentInputGenCHROMIUM, context, program, location, genMode,
+                      components, coeffs);
+        if (context->skipValidation() ||
+            ValidateProgramPathFragmentInputGenCHROMIUM(context, program, location, genMode,
+                                                        components, coeffs))
+        {
+            context->programPathFragmentInputGen(program, location, genMode, components, coeffs);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                 GLuint sourceId,
+                                                 GLint sourceLevel,
+                                                 GLenum destTarget,
+                                                 GLuint destId,
+                                                 GLint destLevel,
+                                                 GLint internalFormat,
+                                                 GLenum destType,
+                                                 GLboolean unpackFlipY,
+                                                 GLboolean unpackPremultiplyAlpha,
+                                                 GLboolean unpackUnmultiplyAlpha)
+{
+    EVENT(
+        "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
+        "%u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = 0x%X, GLboolean "
+        "unpackFlipY = %u, GLboolean unpackPremultiplyAlpha = %u, GLboolean unpackUnmultiplyAlpha "
+        "= %u)",
+        sourceId, sourceLevel, destTarget, destId, destLevel, internalFormat, destType, unpackFlipY,
+        unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget destTargetPacked = FromGLenum<TextureTarget>(destTarget);
+        ANGLE_CAPTURE(CopyTextureCHROMIUM, context, sourceId, sourceLevel, destTargetPacked, destId,
+                      destLevel, internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                      unpackUnmultiplyAlpha);
+        if (context->skipValidation() ||
+            ValidateCopyTextureCHROMIUM(context, sourceId, sourceLevel, destTargetPacked, destId,
+                                        destLevel, internalFormat, destType, unpackFlipY,
+                                        unpackPremultiplyAlpha, unpackUnmultiplyAlpha))
+        {
+            context->copyTexture(sourceId, sourceLevel, destTargetPacked, destId, destLevel,
+                                 internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                                 unpackUnmultiplyAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY CopySubTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                    GLuint sourceId,
+                                                    GLint sourceLevel,
+                                                    GLenum destTarget,
+                                                    GLuint destId,
+                                                    GLint destLevel,
+                                                    GLint xoffset,
+                                                    GLint yoffset,
+                                                    GLint x,
+                                                    GLint y,
+                                                    GLint width,
+                                                    GLint height,
+                                                    GLboolean unpackFlipY,
+                                                    GLboolean unpackPremultiplyAlpha,
+                                                    GLboolean unpackUnmultiplyAlpha)
+{
+    EVENT(
+        "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
+        "%u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint x = %d, GLint y = "
+        "%d, GLint width = %d, GLint height = %d, GLboolean unpackFlipY = %u, GLboolean "
+        "unpackPremultiplyAlpha = %u, GLboolean unpackUnmultiplyAlpha = %u)",
+        sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, x, y, width, height,
+        unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget destTargetPacked = FromGLenum<TextureTarget>(destTarget);
+        ANGLE_CAPTURE(CopySubTextureCHROMIUM, context, sourceId, sourceLevel, destTargetPacked,
+                      destId, destLevel, xoffset, yoffset, x, y, width, height, unpackFlipY,
+                      unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+        if (context->skipValidation() ||
+            ValidateCopySubTextureCHROMIUM(context, sourceId, sourceLevel, destTargetPacked, destId,
+                                           destLevel, xoffset, yoffset, x, y, width, height,
+                                           unpackFlipY, unpackPremultiplyAlpha,
+                                           unpackUnmultiplyAlpha))
+        {
+            context->copySubTexture(sourceId, sourceLevel, destTargetPacked, destId, destLevel,
+                                    xoffset, yoffset, x, y, width, height, unpackFlipY,
+                                    unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedCopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                           GLuint sourceId,
+                                                           GLuint destId)
+{
+    EVENT("(GLuint sourceId = %u, GLuint destId = %u)", sourceId, destId);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(CompressedCopyTextureCHROMIUM, context, sourceId, destId);
+        if (context->skipValidation() ||
+            ValidateCompressedCopyTextureCHROMIUM(context, sourceId, destId))
+        {
+            context->compressedCopyTexture(sourceId, destId);
+        }
+    }
+}
+
+void GL_APIENTRY RequestExtensionANGLEContextANGLE(GLeglContext ctx, const GLchar *name)
+{
+    EVENT("(const GLchar * name = 0x%016" PRIxPTR ")", (uintptr_t)name);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(RequestExtensionANGLE, context, name);
+        if (context->skipValidation() || ValidateRequestExtensionANGLE(context, name))
+        {
+            context->requestExtension(name);
+        }
+    }
+}
+
+void GL_APIENTRY GetBooleanvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLboolean *params)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", GLboolean * params = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetBooleanvRobustANGLE, context, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetBooleanvRobustANGLE(context, pname, bufSize, length, params))
+        {
+            context->getBooleanvRobust(pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferParameterivRobustANGLE, context, targetPacked, pname, bufSize,
+                      length, params);
+        if (context->skipValidation() || ValidateGetBufferParameterivRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFloatvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLfloat *params)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", GLfloat * params = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFloatvRobustANGLE, context, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetFloatvRobustANGLE(context, pname, bufSize, length, params))
+        {
+            context->getFloatvRobust(pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferAttachmentParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                            GLenum target,
+                                                                            GLenum attachment,
+                                                                            GLenum pname,
+                                                                            GLsizei bufSize,
+                                                                            GLsizei *length,
+                                                                            GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = "
+        "%d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, attachment, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFramebufferAttachmentParameterivRobustANGLE, context, target, attachment,
+                      pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetFramebufferAttachmentParameterivRobustANGLE(context, target, attachment,
+                                                                   pname, bufSize, length, params))
+        {
+            context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize,
+                                                               length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetIntegervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", GLint * data = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetIntegervRobustANGLE, context, pname, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetIntegervRobustANGLE(context, pname, bufSize, length, data))
+        {
+            context->getIntegervRobust(pname, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramivRobustANGLE, context, program, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramivRobustANGLE(context, program, pname, bufSize, length, params))
+        {
+            context->getProgramivRobust(program, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetRenderbufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLenum target,
+                                                                   GLenum pname,
+                                                                   GLsizei bufSize,
+                                                                   GLsizei *length,
+                                                                   GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetRenderbufferParameterivRobustANGLE, context, target, pname, bufSize,
+                      length, params);
+        if (context->skipValidation() || ValidateGetRenderbufferParameterivRobustANGLE(
+                                             context, target, pname, bufSize, length, params))
+        {
+            context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetShaderivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                    GLuint shader,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params)
+{
+    EVENT(
+        "(GLuint shader = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        shader, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetShaderivRobustANGLE, context, shader, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetShaderivRobustANGLE(context, shader, pname, bufSize, length, params))
+        {
+            context->getShaderivRobust(shader, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterfvRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetTexParameterfvRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterivRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetTexParameterivRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLint location,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLfloat *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformfvRobustANGLE, context, program, location, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetUniformfvRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getUniformfvRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLint location,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformivRobustANGLE, context, program, location, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetUniformivRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getUniformivRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                          GLuint index,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLfloat *params)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribfvRobustANGLE, context, index, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribfvRobustANGLE(context, index, pname, bufSize, length, params))
+        {
+            context->getVertexAttribfvRobust(index, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                          GLuint index,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLint *params)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribivRobustANGLE, context, index, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribivRobustANGLE(context, index, pname, bufSize, length, params))
+        {
+            context->getVertexAttribivRobust(index, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribPointervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLuint index,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                void **pointer)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", void ** pointer = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)pointer);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribPointervRobustANGLE, context, index, pname, bufSize, length,
+                      pointer);
+        if (context->skipValidation() || ValidateGetVertexAttribPointervRobustANGLE(
+                                             context, index, pname, bufSize, length, pointer))
+        {
+            context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer);
+        }
+    }
+}
+
+void GL_APIENTRY ReadPixelsRobustANGLEContextANGLE(GLeglContext ctx,
+                                                   GLint x,
+                                                   GLint y,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLenum format,
+                                                   GLenum type,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLsizei *columns,
+                                                   GLsizei *rows,
+                                                   void *pixels)
+{
+    EVENT(
+        "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = "
+        "0x%X, GLenum type = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+        ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR
+        ", void * pixels = 0x%016" PRIxPTR ")",
+        x, y, width, height, format, type, bufSize, (uintptr_t)length, (uintptr_t)columns,
+        (uintptr_t)rows, (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ReadPixelsRobustANGLE, context, x, y, width, height, format, type, bufSize,
+                      length, columns, rows, pixels);
+        if (context->skipValidation() ||
+            ValidateReadPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
+                                          length, columns, rows, pixels))
+        {
+            context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
+                                      rows, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLint level,
+                                                   GLint internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLint border,
+                                                   GLenum format,
+                                                   GLenum type,
+                                                   GLsizei bufSize,
+                                                   const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, GLsizei "
+        "bufSize = %d, const void * pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, border, format, type, bufSize,
+        (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage2DRobustANGLE, context, targetPacked, level, internalformat, width,
+                      height, border, format, type, bufSize, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage2DRobustANGLE(context, targetPacked, level, internalformat, width,
+                                          height, border, format, type, bufSize, pixels))
+        {
+            context->texImage2DRobust(targetPacked, level, internalformat, width, height, border,
+                                      format, type, bufSize, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       const GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLfloat * params "
+        "= 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterfvRobustANGLE, context, targetPacked, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterfvRobustANGLE(context, targetPacked, pname, bufSize, params))
+        {
+            context->texParameterfvRobust(targetPacked, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       const GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLint * params = "
+        "0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterivRobustANGLE, context, targetPacked, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterivRobustANGLE(context, targetPacked, pname, bufSize, params))
+        {
+            context->texParameterivRobust(targetPacked, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLint level,
+                                                      GLint xoffset,
+                                                      GLint yoffset,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLenum format,
+                                                      GLenum type,
+                                                      GLsizei bufSize,
+                                                      const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLsizei "
+        "width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, GLsizei "
+        "bufSize = %d, const void * pixels = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, width, height, format, type, bufSize, (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage2DRobustANGLE, context, targetPacked, level, xoffset, yoffset,
+                      width, height, format, type, bufSize, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage2DRobustANGLE(context, targetPacked, level, xoffset, yoffset, width,
+                                             height, format, type, bufSize, pixels))
+        {
+            context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height,
+                                         format, type, bufSize, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLint level,
+                                                   GLint internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLsizei depth,
+                                                   GLint border,
+                                                   GLenum format,
+                                                   GLenum type,
+                                                   GLsizei bufSize,
+                                                   const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = 0x%X, GLenum "
+        "type = 0x%X, GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, format, type, bufSize,
+        (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage3DRobustANGLE, context, targetPacked, level, internalformat, width,
+                      height, depth, border, format, type, bufSize, pixels);
+        if (context->skipValidation() ||
+            ValidateTexImage3DRobustANGLE(context, targetPacked, level, internalformat, width,
+                                          height, depth, border, format, type, bufSize, pixels))
+        {
+            context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth,
+                                      border, format, type, bufSize, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY TexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLint level,
+                                                      GLint xoffset,
+                                                      GLint yoffset,
+                                                      GLint zoffset,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLsizei depth,
+                                                      GLenum format,
+                                                      GLenum type,
+                                                      GLsizei bufSize,
+                                                      const void *pixels)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLenum type = 0x%X, GLsizei bufSize = %d, const void * pixels = 0x%016" PRIxPTR
+        ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize,
+        (uintptr_t)pixels);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexSubImage3DRobustANGLE, context, targetPacked, level, xoffset, yoffset,
+                      zoffset, width, height, depth, format, type, bufSize, pixels);
+        if (context->skipValidation() ||
+            ValidateTexSubImage3DRobustANGLE(context, targetPacked, level, xoffset, yoffset,
+                                             zoffset, width, height, depth, format, type, bufSize,
+                                             pixels))
+        {
+            context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width,
+                                         height, depth, format, type, bufSize, pixels);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLint level,
+                                                             GLenum internalformat,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             GLint border,
+                                                             GLsizei imageSize,
+                                                             GLsizei dataSize,
+                                                             const GLvoid *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, GLsizei dataSize = "
+        "%d, const GLvoid * data = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, border, imageSize, dataSize, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage2DRobustANGLE, context, targetPacked, level, internalformat,
+                      width, height, border, imageSize, dataSize, data);
+        if (context->skipValidation() || ValidateCompressedTexImage2DRobustANGLE(
+                                             context, targetPacked, level, internalformat, width,
+                                             height, border, imageSize, dataSize, data))
+        {
+            context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height,
+                                                border, imageSize, dataSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLint level,
+                                                                GLsizei xoffset,
+                                                                GLsizei yoffset,
+                                                                GLsizei width,
+                                                                GLsizei height,
+                                                                GLenum format,
+                                                                GLsizei imageSize,
+                                                                GLsizei dataSize,
+                                                                const GLvoid *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLsizei xoffset = %d, GLsizei yoffset = %d, "
+        "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLsizei imageSize = %d, "
+        "GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, width, height, format, imageSize, dataSize,
+        (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage2DRobustANGLE, context, targetPacked, level, xoffset,
+                      yoffset, width, height, format, imageSize, dataSize, data);
+        if (context->skipValidation() || ValidateCompressedTexSubImage2DRobustANGLE(
+                                             context, targetPacked, level, xoffset, yoffset, width,
+                                             height, format, imageSize, dataSize, data))
+        {
+            context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width,
+                                                   height, format, imageSize, dataSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLint level,
+                                                             GLenum internalformat,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             GLsizei depth,
+                                                             GLint border,
+                                                             GLsizei imageSize,
+                                                             GLsizei dataSize,
+                                                             const GLvoid *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = "
+        "%d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei imageSize = %d, "
+        "GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR ")",
+        target, level, internalformat, width, height, depth, border, imageSize, dataSize,
+        (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexImage3DRobustANGLE, context, targetPacked, level, internalformat,
+                      width, height, depth, border, imageSize, dataSize, data);
+        if (context->skipValidation() || ValidateCompressedTexImage3DRobustANGLE(
+                                             context, targetPacked, level, internalformat, width,
+                                             height, depth, border, imageSize, dataSize, data))
+        {
+            context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height,
+                                                depth, border, imageSize, dataSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY CompressedTexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLint level,
+                                                                GLint xoffset,
+                                                                GLint yoffset,
+                                                                GLint zoffset,
+                                                                GLsizei width,
+                                                                GLsizei height,
+                                                                GLsizei depth,
+                                                                GLenum format,
+                                                                GLsizei imageSize,
+                                                                GLsizei dataSize,
+                                                                const GLvoid *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, GLint "
+        "zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLenum format "
+        "= 0x%X, GLsizei imageSize = %d, GLsizei dataSize = %d, const GLvoid * data = "
+        "0x%016" PRIxPTR ")",
+        target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, dataSize,
+        (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(CompressedTexSubImage3DRobustANGLE, context, targetPacked, level, xoffset,
+                      yoffset, zoffset, width, height, depth, format, imageSize, dataSize, data);
+        if (context->skipValidation() ||
+            ValidateCompressedTexSubImage3DRobustANGLE(context, targetPacked, level, xoffset,
+                                                       yoffset, zoffset, width, height, depth,
+                                                       format, imageSize, dataSize, data))
+        {
+            context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset,
+                                                   width, height, depth, format, imageSize,
+                                                   dataSize, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        QueryType targetPacked = FromGLenum<QueryType>(target);
+        ANGLE_CAPTURE(GetQueryivRobustANGLE, context, targetPacked, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryivRobustANGLE(context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getQueryivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                          GLuint id,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLuint *params)
+{
+    EVENT(
+        "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        id, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjectuivRobustANGLE, context, id, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryObjectuivRobustANGLE(context, id, pname, bufSize, length, params))
+        {
+            context->getQueryObjectuivRobust(id, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferPointervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          void **params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", void ** params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferPointervRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetBufferPointervRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetIntegeri_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLuint index,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * data = 0x%016" PRIxPTR ")",
+        target, index, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetIntegeri_vRobustANGLE, context, target, index, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetIntegeri_vRobustANGLE(context, target, index, bufSize, length, data))
+        {
+            context->getIntegeri_vRobust(target, index, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetInternalformativRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum internalformat,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum internalformat = 0x%X, GLenum pname = 0x%X, GLsizei bufSize "
+        "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, internalformat, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetInternalformativRobustANGLE, context, target, internalformat, pname,
+                      bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetInternalformativRobustANGLE(context, target, internalformat, pname, bufSize,
+                                                   length, params))
+        {
+            context->getInternalformativRobust(target, internalformat, pname, bufSize, length,
+                                               params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLuint index,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *params)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribIivRobustANGLE, context, index, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribIivRobustANGLE(context, index, pname, bufSize, length, params))
+        {
+            context->getVertexAttribIivRobust(index, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetVertexAttribIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLuint index,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLuint *params)
+{
+    EVENT(
+        "(GLuint index = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        index, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetVertexAttribIuivRobustANGLE, context, index, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribIuivRobustANGLE(context, index, pname, bufSize, length, params))
+        {
+            context->getVertexAttribIuivRobust(index, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLuint program,
+                                                      GLint location,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLuint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetUniformuivRobustANGLE, context, program, location, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetUniformuivRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getUniformuivRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetActiveUniformBlockivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLuint program,
+                                                                GLuint uniformBlockIndex,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = 0x%X, GLsizei bufSize "
+        "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, uniformBlockIndex, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetActiveUniformBlockivRobustANGLE, context, program, uniformBlockIndex,
+                      pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetActiveUniformBlockivRobustANGLE(context, program, uniformBlockIndex, pname,
+                                                       bufSize, length, params))
+        {
+            context->getActiveUniformBlockivRobust(program, uniformBlockIndex, pname, bufSize,
+                                                   length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetInteger64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint64 *data)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", GLint64 * data = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetInteger64vRobustANGLE, context, pname, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetInteger64vRobustANGLE(context, pname, bufSize, length, data))
+        {
+            context->getInteger64vRobust(pname, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetInteger64i_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLuint index,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint64 *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint64 * data = 0x%016" PRIxPTR ")",
+        target, index, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetInteger64i_vRobustANGLE, context, target, index, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetInteger64i_vRobustANGLE(context, target, index, bufSize, length, data))
+        {
+            context->getInteger64i_vRobust(target, index, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetBufferParameteri64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLint64 *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        BufferBinding targetPacked = FromGLenum<BufferBinding>(target);
+        ANGLE_CAPTURE(GetBufferParameteri64vRobustANGLE, context, targetPacked, pname, bufSize,
+                      length, params);
+        if (context->skipValidation() || ValidateGetBufferParameteri64vRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLuint sampler,
+                                                           GLuint pname,
+                                                           GLsizei bufSize,
+                                                           const GLint *param)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLuint pname = %u, GLsizei bufSize = %d, const GLint * param = "
+        "0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameterivRobustANGLE, context, sampler, pname, bufSize, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterivRobustANGLE(context, sampler, pname, bufSize, param))
+        {
+            context->samplerParameterivRobust(sampler, pname, bufSize, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLuint sampler,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           const GLfloat *param)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLfloat * param = "
+        "0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameterfvRobustANGLE, context, sampler, pname, bufSize, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterfvRobustANGLE(context, sampler, pname, bufSize, param))
+        {
+            context->samplerParameterfvRobust(sampler, pname, bufSize, param);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                              GLuint sampler,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLint *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSamplerParameterivRobustANGLE, context, sampler, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetSamplerParameterivRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getSamplerParameterivRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                              GLuint sampler,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLfloat *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSamplerParameterfvRobustANGLE, context, sampler, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetSamplerParameterfvRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getSamplerParameterfvRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetFramebufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLuint sampler,
+                                                                  GLenum pname,
+                                                                  GLsizei bufSize,
+                                                                  GLsizei *length,
+                                                                  GLint *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetFramebufferParameterivRobustANGLE, context, sampler, pname, bufSize,
+                      length, params);
+        if (context->skipValidation() || ValidateGetFramebufferParameterivRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getFramebufferParameterivRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramInterfaceivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                              GLuint program,
+                                                              GLenum programInterface,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLenum programInterface = 0x%X, GLenum pname = 0x%X, GLsizei "
+        "bufSize = %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, programInterface, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetProgramInterfaceivRobustANGLE, context, program, programInterface, pname,
+                      bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetProgramInterfaceivRobustANGLE(context, program, programInterface, pname,
+                                                     bufSize, length, params))
+        {
+            context->getProgramInterfaceivRobust(program, programInterface, pname, bufSize, length,
+                                                 params);
+        }
+    }
+}
+
+void GL_APIENTRY GetBooleani_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLuint index,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLboolean *data)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLuint index = %u, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLboolean * data = 0x%016" PRIxPTR ")",
+        target, index, bufSize, (uintptr_t)length, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetBooleani_vRobustANGLE, context, target, index, bufSize, length, data);
+        if (context->skipValidation() ||
+            ValidateGetBooleani_vRobustANGLE(context, target, index, bufSize, length, data))
+        {
+            context->getBooleani_vRobust(target, index, bufSize, length, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetMultisamplefvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                         GLenum pname,
+                                                         GLuint index,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLfloat *val)
+{
+    EVENT(
+        "(GLenum pname = 0x%X, GLuint index = %u, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * val = 0x%016" PRIxPTR ")",
+        pname, index, bufSize, (uintptr_t)length, (uintptr_t)val);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetMultisamplefvRobustANGLE, context, pname, index, bufSize, length, val);
+        if (context->skipValidation() ||
+            ValidateGetMultisamplefvRobustANGLE(context, pname, index, bufSize, length, val))
+        {
+            context->getMultisamplefvRobust(pname, index, bufSize, length, val);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLint level,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLsizei bufSize = %d, "
+        "GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, level, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterivRobustANGLE, context, targetPacked, level, pname,
+                      bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterivRobustANGLE(context, targetPacked, level, pname, bufSize,
+                                                      length, params))
+        {
+            context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length,
+                                                  params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLint level,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLsizei bufSize = %d, "
+        "GLsizei * length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        target, level, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterfvRobustANGLE, context, targetPacked, level, pname,
+                      bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterfvRobustANGLE(context, targetPacked, level, pname, bufSize,
+                                                      length, params))
+        {
+            context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length,
+                                                  params);
+        }
+    }
+}
+
+void GL_APIENTRY GetPointervRobustANGLERobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               void **params)
+{
+    EVENT("(GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+          ", void ** params = 0x%016" PRIxPTR ")",
+          pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetPointervRobustANGLERobustANGLE, context, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetPointervRobustANGLERobustANGLE(context, pname, bufSize, length, params))
+        {
+            context->getPointervRobustANGLERobust(pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY ReadnPixelsRobustANGLEContextANGLE(GLeglContext ctx,
+                                                    GLint x,
+                                                    GLint y,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLenum format,
+                                                    GLenum type,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLsizei *columns,
+                                                    GLsizei *rows,
+                                                    void *data)
+{
+    EVENT(
+        "(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = "
+        "0x%X, GLenum type = 0x%X, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR
+        ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR
+        ", void * data = 0x%016" PRIxPTR ")",
+        x, y, width, height, format, type, bufSize, (uintptr_t)length, (uintptr_t)columns,
+        (uintptr_t)rows, (uintptr_t)data);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(ReadnPixelsRobustANGLE, context, x, y, width, height, format, type, bufSize,
+                      length, columns, rows, data);
+        if (context->skipValidation() ||
+            ValidateReadnPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize,
+                                           length, columns, rows, data))
+        {
+            context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns,
+                                       rows, data);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLuint program,
+                                                      GLint location,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLfloat *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetnUniformfvRobustANGLE, context, program, location, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformfvRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getnUniformfvRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLuint program,
+                                                      GLint location,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetnUniformivRobustANGLE, context, program, location, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformivRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getnUniformivRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetnUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLuint *params)
+{
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        program, location, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetnUniformuivRobustANGLE, context, program, location, bufSize, length,
+                      params);
+        if (context->skipValidation() ||
+            ValidateGetnUniformuivRobustANGLE(context, program, location, bufSize, length, params))
+        {
+            context->getnUniformuivRobust(program, location, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        const GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLint * params = "
+        "0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterIivRobustANGLE, context, targetPacked, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterIivRobustANGLE(context, targetPacked, pname, bufSize, params))
+        {
+            context->texParameterIivRobust(targetPacked, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY TexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         const GLuint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLuint * params = "
+        "0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexParameterIuivRobustANGLE, context, targetPacked, pname, bufSize, params);
+        if (context->skipValidation() ||
+            ValidateTexParameterIuivRobustANGLE(context, targetPacked, pname, bufSize, params))
+        {
+            context->texParameterIuivRobust(targetPacked, pname, bufSize, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterIivRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetTexParameterIivRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLuint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        target, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(GetTexParameterIuivRobustANGLE, context, targetPacked, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetTexParameterIuivRobustANGLE(
+                                             context, targetPacked, pname, bufSize, length, params))
+        {
+            context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLuint sampler,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            const GLint *param)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLint * param = "
+        "0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameterIivRobustANGLE, context, sampler, pname, bufSize, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterIivRobustANGLE(context, sampler, pname, bufSize, param))
+        {
+            context->samplerParameterIivRobust(sampler, pname, bufSize, param);
+        }
+    }
+}
+
+void GL_APIENTRY SamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLuint sampler,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             const GLuint *param)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, const GLuint * param = "
+        "0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)param);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SamplerParameterIuivRobustANGLE, context, sampler, pname, bufSize, param);
+        if (context->skipValidation() ||
+            ValidateSamplerParameterIuivRobustANGLE(context, sampler, pname, bufSize, param))
+        {
+            context->samplerParameterIuivRobust(sampler, pname, bufSize, param);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLuint sampler,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLint *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSamplerParameterIivRobustANGLE, context, sampler, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetSamplerParameterIivRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getSamplerParameterIivRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetSamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLuint sampler,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLuint *params)
+{
+    EVENT(
+        "(GLuint sampler = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR ")",
+        sampler, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetSamplerParameterIuivRobustANGLE, context, sampler, pname, bufSize, length,
+                      params);
+        if (context->skipValidation() || ValidateGetSamplerParameterIuivRobustANGLE(
+                                             context, sampler, pname, bufSize, length, params))
+        {
+            context->getSamplerParameterIuivRobust(sampler, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                         GLuint id,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLint *params)
+{
+    EVENT(
+        "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR ")",
+        id, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjectivRobustANGLE, context, id, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryObjectivRobustANGLE(context, id, pname, bufSize, length, params))
+        {
+            context->getQueryObjectivRobust(id, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjecti64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLuint id,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint64 *params)
+{
+    EVENT(
+        "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR ")",
+        id, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjecti64vRobustANGLE, context, id, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryObjecti64vRobustANGLE(context, id, pname, bufSize, length, params))
+        {
+            context->getQueryObjecti64vRobust(id, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetQueryObjectui64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLuint id,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLuint64 *params)
+{
+    EVENT(
+        "(GLuint id = %u, GLenum pname = 0x%X, GLsizei bufSize = %d, GLsizei * length = "
+        "0x%016" PRIxPTR ", GLuint64 * params = 0x%016" PRIxPTR ")",
+        id, pname, bufSize, (uintptr_t)length, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetQueryObjectui64vRobustANGLE, context, id, pname, bufSize, length, params);
+        if (context->skipValidation() ||
+            ValidateGetQueryObjectui64vRobustANGLE(context, id, pname, bufSize, length, params))
+        {
+            context->getQueryObjectui64vRobust(id, pname, bufSize, length, params);
+        }
+    }
+}
+
+void GL_APIENTRY CopyTexture3DANGLEContextANGLE(GLeglContext ctx,
+                                                GLuint sourceId,
+                                                GLint sourceLevel,
+                                                GLenum destTarget,
+                                                GLuint destId,
+                                                GLint destLevel,
+                                                GLint internalFormat,
+                                                GLenum destType,
+                                                GLboolean unpackFlipY,
+                                                GLboolean unpackPremultiplyAlpha,
+                                                GLboolean unpackUnmultiplyAlpha)
+{
+    EVENT(
+        "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
+        "%u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = 0x%X, GLboolean "
+        "unpackFlipY = %u, GLboolean unpackPremultiplyAlpha = %u, GLboolean unpackUnmultiplyAlpha "
+        "= %u)",
+        sourceId, sourceLevel, destTarget, destId, destLevel, internalFormat, destType, unpackFlipY,
+        unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget destTargetPacked = FromGLenum<TextureTarget>(destTarget);
+        ANGLE_CAPTURE(CopyTexture3DANGLE, context, sourceId, sourceLevel, destTargetPacked, destId,
+                      destLevel, internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                      unpackUnmultiplyAlpha);
+        if (context->skipValidation() ||
+            ValidateCopyTexture3DANGLE(context, sourceId, sourceLevel, destTargetPacked, destId,
+                                       destLevel, internalFormat, destType, unpackFlipY,
+                                       unpackPremultiplyAlpha, unpackUnmultiplyAlpha))
+        {
+            context->copyTexture3D(sourceId, sourceLevel, destTargetPacked, destId, destLevel,
+                                   internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                                   unpackUnmultiplyAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY CopySubTexture3DANGLEContextANGLE(GLeglContext ctx,
+                                                   GLuint sourceId,
+                                                   GLint sourceLevel,
+                                                   GLenum destTarget,
+                                                   GLuint destId,
+                                                   GLint destLevel,
+                                                   GLint xoffset,
+                                                   GLint yoffset,
+                                                   GLint zoffset,
+                                                   GLint x,
+                                                   GLint y,
+                                                   GLint z,
+                                                   GLint width,
+                                                   GLint height,
+                                                   GLint depth,
+                                                   GLboolean unpackFlipY,
+                                                   GLboolean unpackPremultiplyAlpha,
+                                                   GLboolean unpackUnmultiplyAlpha)
+{
+    EVENT(
+        "(GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = 0x%X, GLuint destId = "
+        "%u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint zoffset = %d, "
+        "GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height = %d, GLint "
+        "depth = %d, GLboolean unpackFlipY = %u, GLboolean unpackPremultiplyAlpha = %u, GLboolean "
+        "unpackUnmultiplyAlpha = %u)",
+        sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, zoffset, x, y, z,
+        width, height, depth, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget destTargetPacked = FromGLenum<TextureTarget>(destTarget);
+        ANGLE_CAPTURE(CopySubTexture3DANGLE, context, sourceId, sourceLevel, destTargetPacked,
+                      destId, destLevel, xoffset, yoffset, zoffset, x, y, z, width, height, depth,
+                      unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+        if (context->skipValidation() ||
+            ValidateCopySubTexture3DANGLE(context, sourceId, sourceLevel, destTargetPacked, destId,
+                                          destLevel, xoffset, yoffset, zoffset, x, y, z, width,
+                                          height, depth, unpackFlipY, unpackPremultiplyAlpha,
+                                          unpackUnmultiplyAlpha))
+        {
+            context->copySubTexture3D(sourceId, sourceLevel, destTargetPacked, destId, destLevel,
+                                      xoffset, yoffset, zoffset, x, y, z, width, height, depth,
+                                      unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+        }
+    }
+}
+
+void GL_APIENTRY TexStorage2DMultisampleANGLEContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLsizei samples,
+                                                          GLenum internalformat,
+                                                          GLsizei width,
+                                                          GLsizei height,
+                                                          GLboolean fixedsamplelocations)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width "
+        "= %d, GLsizei height = %d, GLboolean fixedsamplelocations = %u)",
+        target, samples, internalformat, width, height, fixedsamplelocations);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(TexStorage2DMultisampleANGLE, context, targetPacked, samples, internalformat,
+                      width, height, fixedsamplelocations);
+        if (context->skipValidation() ||
+            ValidateTexStorage2DMultisampleANGLE(context, targetPacked, samples, internalformat,
+                                                 width, height, fixedsamplelocations))
+        {
+            context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height,
+                                             fixedsamplelocations);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterivANGLEContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLint level,
+                                                         GLenum pname,
+                                                         GLint *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLint * params = "
+        "0x%016" PRIxPTR ")",
+        target, level, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterivANGLE, context, targetPacked, level, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterivANGLE(context, targetPacked, level, pname, params))
+        {
+            context->getTexLevelParameteriv(targetPacked, level, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY GetTexLevelParameterfvANGLEContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLint level,
+                                                         GLenum pname,
+                                                         GLfloat *params)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLfloat * params = "
+        "0x%016" PRIxPTR ")",
+        target, level, pname, (uintptr_t)params);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(GetTexLevelParameterfvANGLE, context, targetPacked, level, pname, params);
+        if (context->skipValidation() ||
+            ValidateGetTexLevelParameterfvANGLE(context, targetPacked, level, pname, params))
+        {
+            context->getTexLevelParameterfv(targetPacked, level, pname, params);
+        }
+    }
+}
+
+void GL_APIENTRY MultiDrawArraysANGLEContextANGLE(GLeglContext ctx,
+                                                  GLenum mode,
+                                                  const GLint *firsts,
+                                                  const GLsizei *counts,
+                                                  GLsizei drawcount)
+{
+    EVENT("(GLenum mode = 0x%X, const GLint *firsts = 0x%016" PRIxPTR
+          ", const GLsizei *counts = 0x%016" PRIxPTR ", GLsizei drawcount = %d)",
+          mode, (uintptr_t)firsts, (uintptr_t)counts, drawcount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(MultiDrawArraysANGLE, context, modePacked, firsts, counts, drawcount);
+        if (context->skipValidation() ||
+            ValidateMultiDrawArraysANGLE(context, modePacked, firsts, counts, drawcount))
+        {
+            context->multiDrawArrays(modePacked, firsts, counts, drawcount);
+        }
+    }
+}
+
+void GL_APIENTRY MultiDrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                           GLenum mode,
+                                                           const GLint *firsts,
+                                                           const GLsizei *counts,
+                                                           const GLsizei *instanceCounts,
+                                                           GLsizei drawcount)
+{
+    EVENT("(GLenum mode = 0x%X, const GLint *firsts = 0x%016" PRIxPTR
+          ", const GLsizei *counts = 0x%016" PRIxPTR
+          ", const GLsizei *instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d)",
+          mode, (uintptr_t)firsts, (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked = FromGLenum<PrimitiveMode>(mode);
+        ANGLE_CAPTURE(MultiDrawArraysInstancedANGLE, context, modePacked, firsts, counts,
+                      instanceCounts, drawcount);
+        if (context->skipValidation() ||
+            ValidateMultiDrawArraysInstancedANGLE(context, modePacked, firsts, counts,
+                                                  instanceCounts, drawcount))
+        {
+            context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts,
+                                              drawcount);
+        }
+    }
+}
+
+void GL_APIENTRY MultiDrawElementsANGLEContextANGLE(GLeglContext ctx,
+                                                    GLenum mode,
+                                                    const GLsizei *counts,
+                                                    GLenum type,
+                                                    const GLvoid *const *indices,
+                                                    GLsizei drawcount)
+{
+    EVENT("(GLenum mode = 0x%X, const GLsizei *counts = 0x%016" PRIxPTR
+          ", GLenum type = 0x%X, const GLvoid *const*indices = 0x%016" PRIxPTR
+          ", GLsizei drawcount = %d)",
+          mode, (uintptr_t)counts, type, (uintptr_t)indices, drawcount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(MultiDrawElementsANGLE, context, modePacked, counts, typePacked, indices,
+                      drawcount);
+        if (context->skipValidation() ||
+            ValidateMultiDrawElementsANGLE(context, modePacked, counts, typePacked, indices,
+                                           drawcount))
+        {
+            context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount);
+        }
+    }
+}
+
+void GL_APIENTRY MultiDrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                             GLenum mode,
+                                                             const GLsizei *counts,
+                                                             GLenum type,
+                                                             const GLvoid *const *indices,
+                                                             const GLsizei *instanceCounts,
+                                                             GLsizei drawcount)
+{
+    EVENT("(GLenum mode = 0x%X, const GLsizei *counts = 0x%016" PRIxPTR
+          ", GLenum type = 0x%X, const GLvoid *const*indices = 0x%016" PRIxPTR
+          ", const GLsizei*instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d)",
+          mode, (uintptr_t)counts, type, (uintptr_t)indices, (uintptr_t)instanceCounts, drawcount);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        PrimitiveMode modePacked    = FromGLenum<PrimitiveMode>(mode);
+        DrawElementsType typePacked = FromGLenum<DrawElementsType>(type);
+        ANGLE_CAPTURE(MultiDrawElementsInstancedANGLE, context, modePacked, counts, typePacked,
+                      indices, instanceCounts, drawcount);
+        if (context->skipValidation() ||
+            ValidateMultiDrawElementsInstancedANGLE(context, modePacked, counts, typePacked,
+                                                    indices, instanceCounts, drawcount))
+        {
+            context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices,
+                                                instanceCounts, drawcount);
+        }
+    }
+}
+
+void GL_APIENTRY GetMultisamplefvANGLEContextANGLE(GLeglContext ctx,
+                                                   GLenum pname,
+                                                   GLuint index,
+                                                   GLfloat *val)
+{
+    EVENT("(GLenum pname = 0x%X, GLuint index = %u, GLfloat * val = 0x%016" PRIxPTR ")", pname,
+          index, (uintptr_t)val);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(GetMultisamplefvANGLE, context, pname, index, val);
+        if (context->skipValidation() || ValidateGetMultisamplefvANGLE(context, pname, index, val))
+        {
+            context->getMultisamplefv(pname, index, val);
+        }
+    }
+}
+
+void GL_APIENTRY SampleMaskiANGLEContextANGLE(GLeglContext ctx, GLuint maskNumber, GLbitfield mask)
+{
+    EVENT("(GLuint maskNumber = %u, GLbitfield mask = 0x%X)", maskNumber, mask);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ANGLE_CAPTURE(SampleMaskiANGLE, context, maskNumber, mask);
+        if (context->skipValidation() || ValidateSampleMaskiANGLE(context, maskNumber, mask))
+        {
+            context->sampleMaski(maskNumber, mask);
+        }
+    }
+}
+
+void GL_APIENTRY ProvokingVertexANGLEContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    EVENT("(GLenum mode = 0x%X)", mode);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        ProvokingVertexConvention modePacked = FromGLenum<ProvokingVertexConvention>(mode);
+        ANGLE_CAPTURE(ProvokingVertexANGLE, context, modePacked);
+        if (context->skipValidation() || ValidateProvokingVertexANGLE(context, modePacked))
+        {
+            context->provokingVertex(modePacked);
+        }
+    }
+}
+
+void GL_APIENTRY LoseContextCHROMIUMContextANGLE(GLeglContext ctx, GLenum current, GLenum other)
+{
+    EVENT("(GLenum current = 0x%X, GLenum other = 0x%X)", current, other);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        GraphicsResetStatus currentPacked = FromGLenum<GraphicsResetStatus>(current);
+        GraphicsResetStatus otherPacked   = FromGLenum<GraphicsResetStatus>(other);
+        ANGLE_CAPTURE(LoseContextCHROMIUM, context, currentPacked, otherPacked);
+        if (context->skipValidation() ||
+            ValidateLoseContextCHROMIUM(context, currentPacked, otherPacked))
+        {
+            context->loseContext(currentPacked, otherPacked);
+        }
+    }
+}
+
+void GL_APIENTRY TexImage2DExternalANGLEContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLint level,
+                                                     GLint internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLint border,
+                                                     GLenum format,
+                                                     GLenum type)
+{
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, "
+        "GLsizei height = %d, GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X)",
+        target, level, internalformat, width, height, border, format, type);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureTarget targetPacked = FromGLenum<TextureTarget>(target);
+        ANGLE_CAPTURE(TexImage2DExternalANGLE, context, targetPacked, level, internalformat, width,
+                      height, border, format, type);
+        if (context->skipValidation() ||
+            ValidateTexImage2DExternalANGLE(context, targetPacked, level, internalformat, width,
+                                            height, border, format, type))
+        {
+            context->texImage2DExternal(targetPacked, level, internalformat, width, height, border,
+                                        format, type);
+        }
+    }
+}
+
+void GL_APIENTRY InvalidateTextureANGLEContextANGLE(GLeglContext ctx, GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = static_cast<gl::Context *>(ctx);
+    if (context)
+    {
+        ASSERT(context == GetValidGlobalContext());
+        TextureType targetPacked = FromGLenum<TextureType>(target);
+        ANGLE_CAPTURE(InvalidateTextureANGLE, context, targetPacked);
+        if (context->skipValidation() || ValidateInvalidateTextureANGLE(context, targetPacked))
+        {
+            context->invalidateTexture(targetPacked);
+        }
+    }
+}
+}  // namespace gl
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.h
new file mode 100644
index 0000000000..efc8ee3859
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.h
@@ -0,0 +1,3874 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// entry_points_gles_ext_autogen.h:
+//   Defines the GLES extension entry points.
+
+#ifndef LIBGLESV2_ENTRY_POINTS_GLES_EXT_AUTOGEN_H_
+#define LIBGLESV2_ENTRY_POINTS_GLES_EXT_AUTOGEN_H_
+
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <export.h>
+
+namespace gl
+{
+
+// GL_ANGLE_copy_texture_3d
+ANGLE_EXPORT void GL_APIENTRY CopyTexture3DANGLE(GLuint sourceId,
+                                                 GLint sourceLevel,
+                                                 GLenum destTarget,
+                                                 GLuint destId,
+                                                 GLint destLevel,
+                                                 GLint internalFormat,
+                                                 GLenum destType,
+                                                 GLboolean unpackFlipY,
+                                                 GLboolean unpackPremultiplyAlpha,
+                                                 GLboolean unpackUnmultiplyAlpha);
+ANGLE_EXPORT void GL_APIENTRY CopySubTexture3DANGLE(GLuint sourceId,
+                                                    GLint sourceLevel,
+                                                    GLenum destTarget,
+                                                    GLuint destId,
+                                                    GLint destLevel,
+                                                    GLint xoffset,
+                                                    GLint yoffset,
+                                                    GLint zoffset,
+                                                    GLint x,
+                                                    GLint y,
+                                                    GLint z,
+                                                    GLint width,
+                                                    GLint height,
+                                                    GLint depth,
+                                                    GLboolean unpackFlipY,
+                                                    GLboolean unpackPremultiplyAlpha,
+                                                    GLboolean unpackUnmultiplyAlpha);
+
+// GL_ANGLE_framebuffer_blit
+ANGLE_EXPORT void GL_APIENTRY BlitFramebufferANGLE(GLint srcX0,
+                                                   GLint srcY0,
+                                                   GLint srcX1,
+                                                   GLint srcY1,
+                                                   GLint dstX0,
+                                                   GLint dstY0,
+                                                   GLint dstX1,
+                                                   GLint dstY1,
+                                                   GLbitfield mask,
+                                                   GLenum filter);
+
+// GL_ANGLE_framebuffer_multisample
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageMultisampleANGLE(GLenum target,
+                                                                  GLsizei samples,
+                                                                  GLenum internalformat,
+                                                                  GLsizei width,
+                                                                  GLsizei height);
+
+// GL_ANGLE_instanced_arrays
+ANGLE_EXPORT void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode,
+                                                       GLint first,
+                                                       GLsizei count,
+                                                       GLsizei primcount);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode,
+                                                         GLsizei count,
+                                                         GLenum type,
+                                                         const void *indices,
+                                                         GLsizei primcount);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribDivisorANGLE(GLuint index, GLuint divisor);
+
+// GL_ANGLE_multi_draw
+ANGLE_EXPORT void GL_APIENTRY MultiDrawArraysANGLE(GLenum mode,
+                                                   const GLint *firsts,
+                                                   const GLsizei *counts,
+                                                   GLsizei drawcount);
+ANGLE_EXPORT void GL_APIENTRY MultiDrawArraysInstancedANGLE(GLenum mode,
+                                                            const GLint *firsts,
+                                                            const GLsizei *counts,
+                                                            const GLsizei *instanceCounts,
+                                                            GLsizei drawcount);
+ANGLE_EXPORT void GL_APIENTRY MultiDrawElementsANGLE(GLenum mode,
+                                                     const GLsizei *counts,
+                                                     GLenum type,
+                                                     const GLvoid *const *indices,
+                                                     GLsizei drawcount);
+ANGLE_EXPORT void GL_APIENTRY MultiDrawElementsInstancedANGLE(GLenum mode,
+                                                              const GLsizei *counts,
+                                                              GLenum type,
+                                                              const GLvoid *const *indices,
+                                                              const GLsizei *instanceCounts,
+                                                              GLsizei drawcount);
+
+// GL_ANGLE_provoking_vertex
+ANGLE_EXPORT void GL_APIENTRY ProvokingVertexANGLE(GLenum mode);
+
+// GL_ANGLE_request_extension
+ANGLE_EXPORT void GL_APIENTRY RequestExtensionANGLE(const GLchar *name);
+
+// GL_ANGLE_robust_client_memory
+ANGLE_EXPORT void GL_APIENTRY GetBooleanvRobustANGLE(GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLboolean *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameterivRobustANGLE(GLenum target,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetFloatvRobustANGLE(GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
+                                                                             GLenum attachment,
+                                                                             GLenum pname,
+                                                                             GLsizei bufSize,
+                                                                             GLsizei *length,
+                                                                             GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetIntegervRobustANGLE(GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetProgramivRobustANGLE(GLuint program,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetRenderbufferParameterivRobustANGLE(GLenum target,
+                                                                    GLenum pname,
+                                                                    GLsizei bufSize,
+                                                                    GLsizei *length,
+                                                                    GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetShaderivRobustANGLE(GLuint shader,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterfvRobustANGLE(GLenum target,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterivRobustANGLE(GLenum target,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformfvRobustANGLE(GLuint program,
+                                                      GLint location,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformivRobustANGLE(GLuint program,
+                                                      GLint location,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribfvRobustANGLE(GLuint index,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribivRobustANGLE(GLuint index,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribPointervRobustANGLE(GLuint index,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 void **pointer);
+ANGLE_EXPORT void GL_APIENTRY ReadPixelsRobustANGLE(GLint x,
+                                                    GLint y,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLenum format,
+                                                    GLenum type,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLsizei *columns,
+                                                    GLsizei *rows,
+                                                    void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexImage2DRobustANGLE(GLenum target,
+                                                    GLint level,
+                                                    GLint internalformat,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLint border,
+                                                    GLenum format,
+                                                    GLenum type,
+                                                    GLsizei bufSize,
+                                                    const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexParameterfvRobustANGLE(GLenum target,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterivRobustANGLE(GLenum target,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage2DRobustANGLE(GLenum target,
+                                                       GLint level,
+                                                       GLint xoffset,
+                                                       GLint yoffset,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLenum format,
+                                                       GLenum type,
+                                                       GLsizei bufSize,
+                                                       const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexImage3DRobustANGLE(GLenum target,
+                                                    GLint level,
+                                                    GLint internalformat,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLsizei depth,
+                                                    GLint border,
+                                                    GLenum format,
+                                                    GLenum type,
+                                                    GLsizei bufSize,
+                                                    const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage3DRobustANGLE(GLenum target,
+                                                       GLint level,
+                                                       GLint xoffset,
+                                                       GLint yoffset,
+                                                       GLint zoffset,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLsizei depth,
+                                                       GLenum format,
+                                                       GLenum type,
+                                                       GLsizei bufSize,
+                                                       const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage2DRobustANGLE(GLenum target,
+                                                              GLint level,
+                                                              GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height,
+                                                              GLint border,
+                                                              GLsizei imageSize,
+                                                              GLsizei dataSize,
+                                                              const GLvoid *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage2DRobustANGLE(GLenum target,
+                                                                 GLint level,
+                                                                 GLsizei xoffset,
+                                                                 GLsizei yoffset,
+                                                                 GLsizei width,
+                                                                 GLsizei height,
+                                                                 GLenum format,
+                                                                 GLsizei imageSize,
+                                                                 GLsizei dataSize,
+                                                                 const GLvoid *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage3DRobustANGLE(GLenum target,
+                                                              GLint level,
+                                                              GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height,
+                                                              GLsizei depth,
+                                                              GLint border,
+                                                              GLsizei imageSize,
+                                                              GLsizei dataSize,
+                                                              const GLvoid *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage3DRobustANGLE(GLenum target,
+                                                                 GLint level,
+                                                                 GLint xoffset,
+                                                                 GLint yoffset,
+                                                                 GLint zoffset,
+                                                                 GLsizei width,
+                                                                 GLsizei height,
+                                                                 GLsizei depth,
+                                                                 GLenum format,
+                                                                 GLsizei imageSize,
+                                                                 GLsizei dataSize,
+                                                                 const GLvoid *data);
+ANGLE_EXPORT void GL_APIENTRY
+GetQueryivRobustANGLE(GLenum target, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuivRobustANGLE(GLuint id,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferPointervRobustANGLE(GLenum target,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           void **params);
+ANGLE_EXPORT void GL_APIENTRY GetIntegeri_vRobustANGLE(GLenum target,
+                                                       GLuint index,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetInternalformativRobustANGLE(GLenum target,
+                                                             GLenum internalformat,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIivRobustANGLE(GLuint index,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIuivRobustANGLE(GLuint index,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformuivRobustANGLE(GLuint program,
+                                                       GLint location,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockivRobustANGLE(GLuint program,
+                                                                 GLuint uniformBlockIndex,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64vRobustANGLE(GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64i_vRobustANGLE(GLenum target,
+                                                         GLuint index,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameteri64vRobustANGLE(GLenum target,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterivRobustANGLE(GLuint sampler,
+                                                            GLuint pname,
+                                                            GLsizei bufSize,
+                                                            const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterfvRobustANGLE(GLuint sampler,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            const GLfloat *param);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterivRobustANGLE(GLuint sampler,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterfvRobustANGLE(GLuint sampler,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferParameterivRobustANGLE(GLuint sampler,
+                                                                   GLenum pname,
+                                                                   GLsizei bufSize,
+                                                                   GLsizei *length,
+                                                                   GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetProgramInterfaceivRobustANGLE(GLuint program,
+                                                               GLenum programInterface,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetBooleani_vRobustANGLE(GLenum target,
+                                                       GLuint index,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLboolean *data);
+ANGLE_EXPORT void GL_APIENTRY GetMultisamplefvRobustANGLE(GLenum pname,
+                                                          GLuint index,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLfloat *val);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterivRobustANGLE(GLenum target,
+                                                                GLint level,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfvRobustANGLE(GLenum target,
+                                                                GLint level,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetPointervRobustANGLERobustANGLE(GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                void **params);
+ANGLE_EXPORT void GL_APIENTRY ReadnPixelsRobustANGLE(GLint x,
+                                                     GLint y,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLenum format,
+                                                     GLenum type,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLsizei *columns,
+                                                     GLsizei *rows,
+                                                     void *data);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformfvRobustANGLE(GLuint program,
+                                                       GLint location,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformivRobustANGLE(GLuint program,
+                                                       GLint location,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformuivRobustANGLE(GLuint program,
+                                                        GLint location,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterIivRobustANGLE(GLenum target,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterIuivRobustANGLE(GLenum target,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          const GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterIivRobustANGLE(GLenum target,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterIuivRobustANGLE(GLenum target,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterIivRobustANGLE(GLuint sampler,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterIuivRobustANGLE(GLuint sampler,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              const GLuint *param);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIivRobustANGLE(GLuint sampler,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIuivRobustANGLE(GLuint sampler,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectivRobustANGLE(GLuint id,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjecti64vRobustANGLE(GLuint id,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectui64vRobustANGLE(GLuint id,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLuint64 *params);
+
+// GL_ANGLE_texture_external_update
+ANGLE_EXPORT void GL_APIENTRY TexImage2DExternalANGLE(GLenum target,
+                                                      GLint level,
+                                                      GLint internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLint border,
+                                                      GLenum format,
+                                                      GLenum type);
+ANGLE_EXPORT void GL_APIENTRY InvalidateTextureANGLE(GLenum target);
+
+// GL_ANGLE_texture_multisample
+ANGLE_EXPORT void GL_APIENTRY TexStorage2DMultisampleANGLE(GLenum target,
+                                                           GLsizei samples,
+                                                           GLenum internalformat,
+                                                           GLsizei width,
+                                                           GLsizei height,
+                                                           GLboolean fixedsamplelocations);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterivANGLE(GLenum target,
+                                                          GLint level,
+                                                          GLenum pname,
+                                                          GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfvANGLE(GLenum target,
+                                                          GLint level,
+                                                          GLenum pname,
+                                                          GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val);
+ANGLE_EXPORT void GL_APIENTRY SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask);
+
+// GL_ANGLE_translated_shader_source
+ANGLE_EXPORT void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader,
+                                                             GLsizei bufsize,
+                                                             GLsizei *length,
+                                                             GLchar *source);
+
+// GL_CHROMIUM_bind_uniform_location
+ANGLE_EXPORT void GL_APIENTRY BindUniformLocationCHROMIUM(GLuint program,
+                                                          GLint location,
+                                                          const GLchar *name);
+
+// GL_CHROMIUM_copy_compressed_texture
+ANGLE_EXPORT void GL_APIENTRY CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId);
+
+// GL_CHROMIUM_copy_texture
+ANGLE_EXPORT void GL_APIENTRY CopyTextureCHROMIUM(GLuint sourceId,
+                                                  GLint sourceLevel,
+                                                  GLenum destTarget,
+                                                  GLuint destId,
+                                                  GLint destLevel,
+                                                  GLint internalFormat,
+                                                  GLenum destType,
+                                                  GLboolean unpackFlipY,
+                                                  GLboolean unpackPremultiplyAlpha,
+                                                  GLboolean unpackUnmultiplyAlpha);
+ANGLE_EXPORT void GL_APIENTRY CopySubTextureCHROMIUM(GLuint sourceId,
+                                                     GLint sourceLevel,
+                                                     GLenum destTarget,
+                                                     GLuint destId,
+                                                     GLint destLevel,
+                                                     GLint xoffset,
+                                                     GLint yoffset,
+                                                     GLint x,
+                                                     GLint y,
+                                                     GLint width,
+                                                     GLint height,
+                                                     GLboolean unpackFlipY,
+                                                     GLboolean unpackPremultiplyAlpha,
+                                                     GLboolean unpackUnmultiplyAlpha);
+
+// GL_CHROMIUM_framebuffer_mixed_samples
+ANGLE_EXPORT void GL_APIENTRY CoverageModulationCHROMIUM(GLenum components);
+ANGLE_EXPORT void GL_APIENTRY MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat *matrix);
+ANGLE_EXPORT void GL_APIENTRY MatrixLoadIdentityCHROMIUM(GLenum matrixMode);
+
+// GL_CHROMIUM_lose_context
+ANGLE_EXPORT void GL_APIENTRY LoseContextCHROMIUM(GLenum current, GLenum other);
+
+// GL_CHROMIUM_path_rendering
+ANGLE_EXPORT GLuint GL_APIENTRY GenPathsCHROMIUM(GLsizei range);
+ANGLE_EXPORT void GL_APIENTRY DeletePathsCHROMIUM(GLuint first, GLsizei range);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsPathCHROMIUM(GLuint path);
+ANGLE_EXPORT void GL_APIENTRY PathCommandsCHROMIUM(GLuint path,
+                                                   GLsizei numCommands,
+                                                   const GLubyte *commands,
+                                                   GLsizei numCoords,
+                                                   GLenum coordType,
+                                                   const void *coords);
+ANGLE_EXPORT void GL_APIENTRY PathParameterfCHROMIUM(GLuint path, GLenum pname, GLfloat value);
+ANGLE_EXPORT void GL_APIENTRY PathParameteriCHROMIUM(GLuint path, GLenum pname, GLint value);
+ANGLE_EXPORT void GL_APIENTRY GetPathParameterfvCHROMIUM(GLuint path, GLenum pname, GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY GetPathParameterivCHROMIUM(GLuint path, GLenum pname, GLint *value);
+ANGLE_EXPORT void GL_APIENTRY PathStencilFuncCHROMIUM(GLenum func, GLint ref, GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilFillPathCHROMIUM(GLuint path, GLenum fillMode, GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilStrokePathCHROMIUM(GLuint path, GLint reference, GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY CoverFillPathCHROMIUM(GLuint path, GLenum coverMode);
+ANGLE_EXPORT void GL_APIENTRY CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode);
+ANGLE_EXPORT void GL_APIENTRY StencilThenCoverFillPathCHROMIUM(GLuint path,
+                                                               GLenum fillMode,
+                                                               GLuint mask,
+                                                               GLenum coverMode);
+ANGLE_EXPORT void GL_APIENTRY StencilThenCoverStrokePathCHROMIUM(GLuint path,
+                                                                 GLint reference,
+                                                                 GLuint mask,
+                                                                 GLenum coverMode);
+ANGLE_EXPORT void GL_APIENTRY CoverFillPathInstancedCHROMIUM(GLsizei numPath,
+                                                             GLenum pathNameType,
+                                                             const void *paths,
+                                                             GLuint pathBase,
+                                                             GLenum coverMode,
+                                                             GLenum transformType,
+                                                             const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY CoverStrokePathInstancedCHROMIUM(GLsizei numPath,
+                                                               GLenum pathNameType,
+                                                               const void *paths,
+                                                               GLuint pathBase,
+                                                               GLenum coverMode,
+                                                               GLenum transformType,
+                                                               const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY StencilStrokePathInstancedCHROMIUM(GLsizei numPath,
+                                                                 GLenum pathNameType,
+                                                                 const void *paths,
+                                                                 GLuint pathBase,
+                                                                 GLint reference,
+                                                                 GLuint mask,
+                                                                 GLenum transformType,
+                                                                 const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY StencilFillPathInstancedCHROMIUM(GLsizei numPaths,
+                                                               GLenum pathNameType,
+                                                               const void *paths,
+                                                               GLuint pathBase,
+                                                               GLenum fillMode,
+                                                               GLuint mask,
+                                                               GLenum transformType,
+                                                               const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY
+StencilThenCoverFillPathInstancedCHROMIUM(GLsizei numPaths,
+                                          GLenum pathNameType,
+                                          const void *paths,
+                                          GLuint pathBase,
+                                          GLenum fillMode,
+                                          GLuint mask,
+                                          GLenum coverMode,
+                                          GLenum transformType,
+                                          const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY
+StencilThenCoverStrokePathInstancedCHROMIUM(GLsizei numPaths,
+                                            GLenum pathNameType,
+                                            const void *paths,
+                                            GLuint pathBase,
+                                            GLint reference,
+                                            GLuint mask,
+                                            GLenum coverMode,
+                                            GLenum transformType,
+                                            const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY BindFragmentInputLocationCHROMIUM(GLuint programs,
+                                                                GLint location,
+                                                                const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY ProgramPathFragmentInputGenCHROMIUM(GLuint program,
+                                                                  GLint location,
+                                                                  GLenum genMode,
+                                                                  GLint components,
+                                                                  const GLfloat *coeffs);
+
+// GL_EXT_blend_func_extended
+ANGLE_EXPORT void GL_APIENTRY BindFragDataLocationEXT(GLuint program,
+                                                      GLuint color,
+                                                      const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY BindFragDataLocationIndexedEXT(GLuint program,
+                                                             GLuint colorNumber,
+                                                             GLuint index,
+                                                             const GLchar *name);
+ANGLE_EXPORT GLint GL_APIENTRY GetFragDataIndexEXT(GLuint program, const GLchar *name);
+ANGLE_EXPORT GLint GL_APIENTRY GetProgramResourceLocationIndexEXT(GLuint program,
+                                                                  GLenum programInterface,
+                                                                  const GLchar *name);
+
+// GL_EXT_debug_marker
+ANGLE_EXPORT void GL_APIENTRY InsertEventMarkerEXT(GLsizei length, const GLchar *marker);
+ANGLE_EXPORT void GL_APIENTRY PopGroupMarkerEXT();
+ANGLE_EXPORT void GL_APIENTRY PushGroupMarkerEXT(GLsizei length, const GLchar *marker);
+
+// GL_EXT_discard_framebuffer
+ANGLE_EXPORT void GL_APIENTRY DiscardFramebufferEXT(GLenum target,
+                                                    GLsizei numAttachments,
+                                                    const GLenum *attachments);
+
+// GL_EXT_disjoint_timer_query
+ANGLE_EXPORT void GL_APIENTRY BeginQueryEXT(GLenum target, GLuint id);
+ANGLE_EXPORT void GL_APIENTRY DeleteQueriesEXT(GLsizei n, const GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY EndQueryEXT(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY GenQueriesEXT(GLsizei n, GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryivEXT(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsQueryEXT(GLuint id);
+ANGLE_EXPORT void GL_APIENTRY QueryCounterEXT(GLuint id, GLenum target);
+
+// GL_EXT_draw_buffers
+ANGLE_EXPORT void GL_APIENTRY DrawBuffersEXT(GLsizei n, const GLenum *bufs);
+
+// GL_EXT_geometry_shader
+ANGLE_EXPORT void GL_APIENTRY FramebufferTextureEXT(GLenum target,
+                                                    GLenum attachment,
+                                                    GLuint texture,
+                                                    GLint level);
+
+// GL_EXT_instanced_arrays
+ANGLE_EXPORT void GL_APIENTRY DrawArraysInstancedEXT(GLenum mode,
+                                                     GLint start,
+                                                     GLsizei count,
+                                                     GLsizei primcount);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsInstancedEXT(GLenum mode,
+                                                       GLsizei count,
+                                                       GLenum type,
+                                                       const void *indices,
+                                                       GLsizei primcount);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribDivisorEXT(GLuint index, GLuint divisor);
+
+// GL_EXT_map_buffer_range
+ANGLE_EXPORT void GL_APIENTRY FlushMappedBufferRangeEXT(GLenum target,
+                                                        GLintptr offset,
+                                                        GLsizeiptr length);
+ANGLE_EXPORT void *GL_APIENTRY MapBufferRangeEXT(GLenum target,
+                                                 GLintptr offset,
+                                                 GLsizeiptr length,
+                                                 GLbitfield access);
+
+// GL_EXT_memory_object
+ANGLE_EXPORT void GL_APIENTRY BufferStorageMemEXT(GLenum target,
+                                                  GLsizeiptr size,
+                                                  GLuint memory,
+                                                  GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects);
+ANGLE_EXPORT void GL_APIENTRY DeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects);
+ANGLE_EXPORT void GL_APIENTRY GetMemoryObjectParameterivEXT(GLuint memoryObject,
+                                                            GLenum pname,
+                                                            GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetUnsignedBytevEXT(GLenum pname, GLubyte *data);
+ANGLE_EXPORT void GL_APIENTRY GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsMemoryObjectEXT(GLuint memoryObject);
+ANGLE_EXPORT void GL_APIENTRY MemoryObjectParameterivEXT(GLuint memoryObject,
+                                                         GLenum pname,
+                                                         const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexStorageMem2DEXT(GLenum target,
+                                                 GLsizei levels,
+                                                 GLenum internalFormat,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLuint memory,
+                                                 GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY TexStorageMem2DMultisampleEXT(GLenum target,
+                                                            GLsizei samples,
+                                                            GLenum internalFormat,
+                                                            GLsizei width,
+                                                            GLsizei height,
+                                                            GLboolean fixedSampleLocations,
+                                                            GLuint memory,
+                                                            GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY TexStorageMem3DEXT(GLenum target,
+                                                 GLsizei levels,
+                                                 GLenum internalFormat,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLsizei depth,
+                                                 GLuint memory,
+                                                 GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY TexStorageMem3DMultisampleEXT(GLenum target,
+                                                            GLsizei samples,
+                                                            GLenum internalFormat,
+                                                            GLsizei width,
+                                                            GLsizei height,
+                                                            GLsizei depth,
+                                                            GLboolean fixedSampleLocations,
+                                                            GLuint memory,
+                                                            GLuint64 offset);
+
+// GL_EXT_memory_object_fd
+ANGLE_EXPORT void GL_APIENTRY ImportMemoryFdEXT(GLuint memory,
+                                                GLuint64 size,
+                                                GLenum handleType,
+                                                GLint fd);
+
+// GL_EXT_occlusion_query_boolean
+
+// GL_EXT_robustness
+ANGLE_EXPORT GLenum GL_APIENTRY GetGraphicsResetStatusEXT();
+ANGLE_EXPORT void GL_APIENTRY GetnUniformfvEXT(GLuint program,
+                                               GLint location,
+                                               GLsizei bufSize,
+                                               GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformivEXT(GLuint program,
+                                               GLint location,
+                                               GLsizei bufSize,
+                                               GLint *params);
+ANGLE_EXPORT void GL_APIENTRY ReadnPixelsEXT(GLint x,
+                                             GLint y,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLenum format,
+                                             GLenum type,
+                                             GLsizei bufSize,
+                                             void *data);
+
+// GL_EXT_semaphore
+ANGLE_EXPORT void GL_APIENTRY DeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores);
+ANGLE_EXPORT void GL_APIENTRY GenSemaphoresEXT(GLsizei n, GLuint *semaphores);
+ANGLE_EXPORT void GL_APIENTRY GetSemaphoreParameterui64vEXT(GLuint semaphore,
+                                                            GLenum pname,
+                                                            GLuint64 *params);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsSemaphoreEXT(GLuint semaphore);
+ANGLE_EXPORT void GL_APIENTRY SemaphoreParameterui64vEXT(GLuint semaphore,
+                                                         GLenum pname,
+                                                         const GLuint64 *params);
+ANGLE_EXPORT void GL_APIENTRY SignalSemaphoreEXT(GLuint semaphore,
+                                                 GLuint numBufferBarriers,
+                                                 const GLuint *buffers,
+                                                 GLuint numTextureBarriers,
+                                                 const GLuint *textures,
+                                                 const GLenum *dstLayouts);
+ANGLE_EXPORT void GL_APIENTRY WaitSemaphoreEXT(GLuint semaphore,
+                                               GLuint numBufferBarriers,
+                                               const GLuint *buffers,
+                                               GLuint numTextureBarriers,
+                                               const GLuint *textures,
+                                               const GLenum *srcLayouts);
+
+// GL_EXT_semaphore_fd
+ANGLE_EXPORT void GL_APIENTRY ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd);
+
+// GL_EXT_texture_storage
+ANGLE_EXPORT void GL_APIENTRY TexStorage1DEXT(GLenum target,
+                                              GLsizei levels,
+                                              GLenum internalformat,
+                                              GLsizei width);
+ANGLE_EXPORT void GL_APIENTRY TexStorage2DEXT(GLenum target,
+                                              GLsizei levels,
+                                              GLenum internalformat,
+                                              GLsizei width,
+                                              GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY TexStorage3DEXT(GLenum target,
+                                              GLsizei levels,
+                                              GLenum internalformat,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLsizei depth);
+
+// GL_KHR_debug
+ANGLE_EXPORT void GL_APIENTRY DebugMessageCallbackKHR(GLDEBUGPROCKHR callback,
+                                                      const void *userParam);
+ANGLE_EXPORT void GL_APIENTRY DebugMessageControlKHR(GLenum source,
+                                                     GLenum type,
+                                                     GLenum severity,
+                                                     GLsizei count,
+                                                     const GLuint *ids,
+                                                     GLboolean enabled);
+ANGLE_EXPORT void GL_APIENTRY DebugMessageInsertKHR(GLenum source,
+                                                    GLenum type,
+                                                    GLuint id,
+                                                    GLenum severity,
+                                                    GLsizei length,
+                                                    const GLchar *buf);
+ANGLE_EXPORT GLuint GL_APIENTRY GetDebugMessageLogKHR(GLuint count,
+                                                      GLsizei bufSize,
+                                                      GLenum *sources,
+                                                      GLenum *types,
+                                                      GLuint *ids,
+                                                      GLenum *severities,
+                                                      GLsizei *lengths,
+                                                      GLchar *messageLog);
+ANGLE_EXPORT void GL_APIENTRY
+GetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
+ANGLE_EXPORT void GL_APIENTRY GetObjectPtrLabelKHR(const void *ptr,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLchar *label);
+ANGLE_EXPORT void GL_APIENTRY GetPointervKHR(GLenum pname, void **params);
+ANGLE_EXPORT void GL_APIENTRY ObjectLabelKHR(GLenum identifier,
+                                             GLuint name,
+                                             GLsizei length,
+                                             const GLchar *label);
+ANGLE_EXPORT void GL_APIENTRY ObjectPtrLabelKHR(const void *ptr,
+                                                GLsizei length,
+                                                const GLchar *label);
+ANGLE_EXPORT void GL_APIENTRY PopDebugGroupKHR();
+ANGLE_EXPORT void GL_APIENTRY PushDebugGroupKHR(GLenum source,
+                                                GLuint id,
+                                                GLsizei length,
+                                                const GLchar *message);
+
+// GL_KHR_parallel_shader_compile
+ANGLE_EXPORT void GL_APIENTRY MaxShaderCompilerThreadsKHR(GLuint count);
+
+// GL_NV_fence
+ANGLE_EXPORT void GL_APIENTRY DeleteFencesNV(GLsizei n, const GLuint *fences);
+ANGLE_EXPORT void GL_APIENTRY FinishFenceNV(GLuint fence);
+ANGLE_EXPORT void GL_APIENTRY GenFencesNV(GLsizei n, GLuint *fences);
+ANGLE_EXPORT void GL_APIENTRY GetFenceivNV(GLuint fence, GLenum pname, GLint *params);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsFenceNV(GLuint fence);
+ANGLE_EXPORT void GL_APIENTRY SetFenceNV(GLuint fence, GLenum condition);
+ANGLE_EXPORT GLboolean GL_APIENTRY TestFenceNV(GLuint fence);
+
+// GL_OES_EGL_image
+ANGLE_EXPORT void GL_APIENTRY EGLImageTargetRenderbufferStorageOES(GLenum target,
+                                                                   GLeglImageOES image);
+ANGLE_EXPORT void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image);
+
+// GL_OES_draw_texture
+ANGLE_EXPORT void GL_APIENTRY
+DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
+ANGLE_EXPORT void GL_APIENTRY DrawTexfvOES(const GLfloat *coords);
+ANGLE_EXPORT void GL_APIENTRY DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height);
+ANGLE_EXPORT void GL_APIENTRY DrawTexivOES(const GLint *coords);
+ANGLE_EXPORT void GL_APIENTRY
+DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height);
+ANGLE_EXPORT void GL_APIENTRY DrawTexsvOES(const GLshort *coords);
+ANGLE_EXPORT void GL_APIENTRY
+DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height);
+ANGLE_EXPORT void GL_APIENTRY DrawTexxvOES(const GLfixed *coords);
+
+// GL_OES_framebuffer_object
+ANGLE_EXPORT void GL_APIENTRY BindFramebufferOES(GLenum target, GLuint framebuffer);
+ANGLE_EXPORT void GL_APIENTRY BindRenderbufferOES(GLenum target, GLuint renderbuffer);
+ANGLE_EXPORT GLenum GL_APIENTRY CheckFramebufferStatusOES(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY DeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers);
+ANGLE_EXPORT void GL_APIENTRY FramebufferRenderbufferOES(GLenum target,
+                                                         GLenum attachment,
+                                                         GLenum renderbuffertarget,
+                                                         GLuint renderbuffer);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTexture2DOES(GLenum target,
+                                                      GLenum attachment,
+                                                      GLenum textarget,
+                                                      GLuint texture,
+                                                      GLint level);
+ANGLE_EXPORT void GL_APIENTRY GenFramebuffersOES(GLsizei n, GLuint *framebuffers);
+ANGLE_EXPORT void GL_APIENTRY GenRenderbuffersOES(GLsizei n, GLuint *renderbuffers);
+ANGLE_EXPORT void GL_APIENTRY GenerateMipmapOES(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferAttachmentParameterivOES(GLenum target,
+                                                                     GLenum attachment,
+                                                                     GLenum pname,
+                                                                     GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetRenderbufferParameterivOES(GLenum target,
+                                                            GLenum pname,
+                                                            GLint *params);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsFramebufferOES(GLuint framebuffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsRenderbufferOES(GLuint renderbuffer);
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageOES(GLenum target,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height);
+
+// GL_OES_get_program_binary
+ANGLE_EXPORT void GL_APIENTRY GetProgramBinaryOES(GLuint program,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLenum *binaryFormat,
+                                                  void *binary);
+ANGLE_EXPORT void GL_APIENTRY ProgramBinaryOES(GLuint program,
+                                               GLenum binaryFormat,
+                                               const void *binary,
+                                               GLint length);
+
+// GL_OES_mapbuffer
+ANGLE_EXPORT void GL_APIENTRY GetBufferPointervOES(GLenum target, GLenum pname, void **params);
+ANGLE_EXPORT void *GL_APIENTRY MapBufferOES(GLenum target, GLenum access);
+ANGLE_EXPORT GLboolean GL_APIENTRY UnmapBufferOES(GLenum target);
+
+// GL_OES_matrix_palette
+ANGLE_EXPORT void GL_APIENTRY CurrentPaletteMatrixOES(GLuint matrixpaletteindex);
+ANGLE_EXPORT void GL_APIENTRY LoadPaletteFromModelViewMatrixOES();
+ANGLE_EXPORT void GL_APIENTRY MatrixIndexPointerOES(GLint size,
+                                                    GLenum type,
+                                                    GLsizei stride,
+                                                    const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY WeightPointerOES(GLint size,
+                                               GLenum type,
+                                               GLsizei stride,
+                                               const void *pointer);
+
+// GL_OES_point_size_array
+ANGLE_EXPORT void GL_APIENTRY PointSizePointerOES(GLenum type, GLsizei stride, const void *pointer);
+
+// GL_OES_query_matrix
+ANGLE_EXPORT GLbitfield GL_APIENTRY QueryMatrixxOES(GLfixed *mantissa, GLint *exponent);
+
+// GL_OES_texture_3D
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage3DOES(GLenum target,
+                                                      GLint level,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLsizei depth,
+                                                      GLint border,
+                                                      GLsizei imageSize,
+                                                      const void *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage3DOES(GLenum target,
+                                                         GLint level,
+                                                         GLint xoffset,
+                                                         GLint yoffset,
+                                                         GLint zoffset,
+                                                         GLsizei width,
+                                                         GLsizei height,
+                                                         GLsizei depth,
+                                                         GLenum format,
+                                                         GLsizei imageSize,
+                                                         const void *data);
+ANGLE_EXPORT void GL_APIENTRY CopyTexSubImage3DOES(GLenum target,
+                                                   GLint level,
+                                                   GLint xoffset,
+                                                   GLint yoffset,
+                                                   GLint zoffset,
+                                                   GLint x,
+                                                   GLint y,
+                                                   GLsizei width,
+                                                   GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTexture3DOES(GLenum target,
+                                                      GLenum attachment,
+                                                      GLenum textarget,
+                                                      GLuint texture,
+                                                      GLint level,
+                                                      GLint zoffset);
+ANGLE_EXPORT void GL_APIENTRY TexImage3DOES(GLenum target,
+                                            GLint level,
+                                            GLenum internalformat,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLint border,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage3DOES(GLenum target,
+                                               GLint level,
+                                               GLint xoffset,
+                                               GLint yoffset,
+                                               GLint zoffset,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLsizei depth,
+                                               GLenum format,
+                                               GLenum type,
+                                               const void *pixels);
+
+// GL_OES_texture_border_clamp
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIivOES(GLuint sampler,
+                                                        GLenum pname,
+                                                        GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIuivOES(GLuint sampler,
+                                                         GLenum pname,
+                                                         GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterIivOES(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterIivOES(GLuint sampler,
+                                                     GLenum pname,
+                                                     const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterIuivOES(GLuint sampler,
+                                                      GLenum pname,
+                                                      const GLuint *param);
+ANGLE_EXPORT void GL_APIENTRY TexParameterIivOES(GLenum target, GLenum pname, const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterIuivOES(GLenum target,
+                                                  GLenum pname,
+                                                  const GLuint *params);
+
+// GL_OES_texture_cube_map
+ANGLE_EXPORT void GL_APIENTRY GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexGenivOES(GLenum coord, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY TexGenfOES(GLenum coord, GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY TexGeniOES(GLenum coord, GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY TexGenivOES(GLenum coord, GLenum pname, const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexGenxOES(GLenum coord, GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params);
+
+// GL_OES_texture_storage_multisample_2d_array
+ANGLE_EXPORT void GL_APIENTRY TexStorage3DMultisampleOES(GLenum target,
+                                                         GLsizei samples,
+                                                         GLenum internalformat,
+                                                         GLsizei width,
+                                                         GLsizei height,
+                                                         GLsizei depth,
+                                                         GLboolean fixedsamplelocations);
+
+// GL_OES_vertex_array_object
+ANGLE_EXPORT void GL_APIENTRY BindVertexArrayOES(GLuint array);
+ANGLE_EXPORT void GL_APIENTRY DeleteVertexArraysOES(GLsizei n, const GLuint *arrays);
+ANGLE_EXPORT void GL_APIENTRY GenVertexArraysOES(GLsizei n, GLuint *arrays);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsVertexArrayOES(GLuint array);
+
+// GL_OVR_multiview
+ANGLE_EXPORT void GL_APIENTRY FramebufferTextureMultiviewOVR(GLenum target,
+                                                             GLenum attachment,
+                                                             GLuint texture,
+                                                             GLint level,
+                                                             GLint baseViewIndex,
+                                                             GLsizei numViews);
+
+// GL_OVR_multiview2
+
+// EGL_ANGLE_explicit_context
+ANGLE_EXPORT void GL_APIENTRY ActiveShaderProgramContextANGLE(GLeglContext ctx,
+                                                              GLuint pipeline,
+                                                              GLuint program);
+ANGLE_EXPORT void GL_APIENTRY ActiveTextureContextANGLE(GLeglContext ctx, GLenum texture);
+ANGLE_EXPORT void GL_APIENTRY AlphaFuncContextANGLE(GLeglContext ctx, GLenum func, GLfloat ref);
+ANGLE_EXPORT void GL_APIENTRY AlphaFuncxContextANGLE(GLeglContext ctx, GLenum func, GLfixed ref);
+ANGLE_EXPORT void GL_APIENTRY AttachShaderContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLuint shader);
+ANGLE_EXPORT void GL_APIENTRY BeginQueryContextANGLE(GLeglContext ctx, GLenum target, GLuint id);
+ANGLE_EXPORT void GL_APIENTRY BeginQueryEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint id);
+ANGLE_EXPORT void GL_APIENTRY BeginTransformFeedbackContextANGLE(GLeglContext ctx,
+                                                                 GLenum primitiveMode);
+ANGLE_EXPORT void GL_APIENTRY BindAttribLocationContextANGLE(GLeglContext ctx,
+                                                             GLuint program,
+                                                             GLuint index,
+                                                             const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY BindBufferContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLuint buffer);
+ANGLE_EXPORT void GL_APIENTRY BindBufferBaseContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLuint index,
+                                                         GLuint buffer);
+ANGLE_EXPORT void GL_APIENTRY BindBufferRangeContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLuint index,
+                                                          GLuint buffer,
+                                                          GLintptr offset,
+                                                          GLsizeiptr size);
+ANGLE_EXPORT void GL_APIENTRY BindFragDataLocationEXTContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLuint color,
+                                                                  const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY BindFragDataLocationIndexedEXTContextANGLE(GLeglContext ctx,
+                                                                         GLuint program,
+                                                                         GLuint colorNumber,
+                                                                         GLuint index,
+                                                                         const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY BindFramebufferContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLuint framebuffer);
+ANGLE_EXPORT void GL_APIENTRY BindFramebufferOESContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLuint framebuffer);
+ANGLE_EXPORT void GL_APIENTRY BindImageTextureContextANGLE(GLeglContext ctx,
+                                                           GLuint unit,
+                                                           GLuint texture,
+                                                           GLint level,
+                                                           GLboolean layered,
+                                                           GLint layer,
+                                                           GLenum access,
+                                                           GLenum format);
+ANGLE_EXPORT void GL_APIENTRY BindProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline);
+ANGLE_EXPORT void GL_APIENTRY BindRenderbufferContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLuint renderbuffer);
+ANGLE_EXPORT void GL_APIENTRY BindRenderbufferOESContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLuint renderbuffer);
+ANGLE_EXPORT void GL_APIENTRY BindSamplerContextANGLE(GLeglContext ctx,
+                                                      GLuint unit,
+                                                      GLuint sampler);
+ANGLE_EXPORT void GL_APIENTRY BindTextureContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLuint texture);
+ANGLE_EXPORT void GL_APIENTRY BindTransformFeedbackContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLuint id);
+ANGLE_EXPORT void GL_APIENTRY BindVertexArrayContextANGLE(GLeglContext ctx, GLuint array);
+ANGLE_EXPORT void GL_APIENTRY BindVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array);
+ANGLE_EXPORT void GL_APIENTRY BindVertexBufferContextANGLE(GLeglContext ctx,
+                                                           GLuint bindingindex,
+                                                           GLuint buffer,
+                                                           GLintptr offset,
+                                                           GLsizei stride);
+ANGLE_EXPORT void GL_APIENTRY
+BlendColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ANGLE_EXPORT void GL_APIENTRY BlendEquationContextANGLE(GLeglContext ctx, GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY BlendEquationSeparateContextANGLE(GLeglContext ctx,
+                                                                GLenum modeRGB,
+                                                                GLenum modeAlpha);
+ANGLE_EXPORT void GL_APIENTRY BlendFuncContextANGLE(GLeglContext ctx,
+                                                    GLenum sfactor,
+                                                    GLenum dfactor);
+ANGLE_EXPORT void GL_APIENTRY BlendFuncSeparateContextANGLE(GLeglContext ctx,
+                                                            GLenum sfactorRGB,
+                                                            GLenum dfactorRGB,
+                                                            GLenum sfactorAlpha,
+                                                            GLenum dfactorAlpha);
+ANGLE_EXPORT void GL_APIENTRY BlitFramebufferContextANGLE(GLeglContext ctx,
+                                                          GLint srcX0,
+                                                          GLint srcY0,
+                                                          GLint srcX1,
+                                                          GLint srcY1,
+                                                          GLint dstX0,
+                                                          GLint dstY0,
+                                                          GLint dstX1,
+                                                          GLint dstY1,
+                                                          GLbitfield mask,
+                                                          GLenum filter);
+ANGLE_EXPORT void GL_APIENTRY BlitFramebufferANGLEContextANGLE(GLeglContext ctx,
+                                                               GLint srcX0,
+                                                               GLint srcY0,
+                                                               GLint srcX1,
+                                                               GLint srcY1,
+                                                               GLint dstX0,
+                                                               GLint dstY0,
+                                                               GLint dstX1,
+                                                               GLint dstY1,
+                                                               GLbitfield mask,
+                                                               GLenum filter);
+ANGLE_EXPORT void GL_APIENTRY BufferDataContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLsizeiptr size,
+                                                     const void *data,
+                                                     GLenum usage);
+ANGLE_EXPORT void GL_APIENTRY BufferStorageMemEXTContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLsizeiptr size,
+                                                              GLuint memory,
+                                                              GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY BufferSubDataContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLintptr offset,
+                                                        GLsizeiptr size,
+                                                        const void *data);
+ANGLE_EXPORT GLenum GL_APIENTRY CheckFramebufferStatusContextANGLE(GLeglContext ctx, GLenum target);
+ANGLE_EXPORT GLenum GL_APIENTRY CheckFramebufferStatusOESContextANGLE(GLeglContext ctx,
+                                                                      GLenum target);
+ANGLE_EXPORT void GL_APIENTRY ClearContextANGLE(GLeglContext ctx, GLbitfield mask);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferfiContextANGLE(GLeglContext ctx,
+                                                        GLenum buffer,
+                                                        GLint drawbuffer,
+                                                        GLfloat depth,
+                                                        GLint stencil);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferfvContextANGLE(GLeglContext ctx,
+                                                        GLenum buffer,
+                                                        GLint drawbuffer,
+                                                        const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferivContextANGLE(GLeglContext ctx,
+                                                        GLenum buffer,
+                                                        GLint drawbuffer,
+                                                        const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferuivContextANGLE(GLeglContext ctx,
+                                                         GLenum buffer,
+                                                         GLint drawbuffer,
+                                                         const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY
+ClearColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ANGLE_EXPORT void GL_APIENTRY
+ClearColorxContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
+ANGLE_EXPORT void GL_APIENTRY ClearDepthfContextANGLE(GLeglContext ctx, GLfloat d);
+ANGLE_EXPORT void GL_APIENTRY ClearDepthxContextANGLE(GLeglContext ctx, GLfixed depth);
+ANGLE_EXPORT void GL_APIENTRY ClearStencilContextANGLE(GLeglContext ctx, GLint s);
+ANGLE_EXPORT void GL_APIENTRY ClientActiveTextureContextANGLE(GLeglContext ctx, GLenum texture);
+ANGLE_EXPORT GLenum GL_APIENTRY ClientWaitSyncContextANGLE(GLeglContext ctx,
+                                                           GLsync sync,
+                                                           GLbitfield flags,
+                                                           GLuint64 timeout);
+ANGLE_EXPORT void GL_APIENTRY ClipPlanefContextANGLE(GLeglContext ctx,
+                                                     GLenum p,
+                                                     const GLfloat *eqn);
+ANGLE_EXPORT void GL_APIENTRY ClipPlanexContextANGLE(GLeglContext ctx,
+                                                     GLenum plane,
+                                                     const GLfixed *equation);
+ANGLE_EXPORT void GL_APIENTRY
+Color4fContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ANGLE_EXPORT void GL_APIENTRY
+Color4ubContextANGLE(GLeglContext ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+ANGLE_EXPORT void GL_APIENTRY
+Color4xContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha);
+ANGLE_EXPORT void GL_APIENTRY ColorMaskContextANGLE(GLeglContext ctx,
+                                                    GLboolean red,
+                                                    GLboolean green,
+                                                    GLboolean blue,
+                                                    GLboolean alpha);
+ANGLE_EXPORT void GL_APIENTRY ColorPointerContextANGLE(GLeglContext ctx,
+                                                       GLint size,
+                                                       GLenum type,
+                                                       GLsizei stride,
+                                                       const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY CompileShaderContextANGLE(GLeglContext ctx, GLuint shader);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage2DContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLint level,
+                                                               GLenum internalformat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               GLint border,
+                                                               GLsizei imageSize,
+                                                               const void *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage3DContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLint level,
+                                                               GLenum internalformat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               GLsizei depth,
+                                                               GLint border,
+                                                               GLsizei imageSize,
+                                                               const void *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage3DOESContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLint level,
+                                                                  GLenum internalformat,
+                                                                  GLsizei width,
+                                                                  GLsizei height,
+                                                                  GLsizei depth,
+                                                                  GLint border,
+                                                                  GLsizei imageSize,
+                                                                  const void *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage2DContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLint level,
+                                                                  GLint xoffset,
+                                                                  GLint yoffset,
+                                                                  GLsizei width,
+                                                                  GLsizei height,
+                                                                  GLenum format,
+                                                                  GLsizei imageSize,
+                                                                  const void *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage3DContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLint level,
+                                                                  GLint xoffset,
+                                                                  GLint yoffset,
+                                                                  GLint zoffset,
+                                                                  GLsizei width,
+                                                                  GLsizei height,
+                                                                  GLsizei depth,
+                                                                  GLenum format,
+                                                                  GLsizei imageSize,
+                                                                  const void *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                                                     GLenum target,
+                                                                     GLint level,
+                                                                     GLint xoffset,
+                                                                     GLint yoffset,
+                                                                     GLint zoffset,
+                                                                     GLsizei width,
+                                                                     GLsizei height,
+                                                                     GLsizei depth,
+                                                                     GLenum format,
+                                                                     GLsizei imageSize,
+                                                                     const void *data);
+ANGLE_EXPORT void GL_APIENTRY CopyBufferSubDataContextANGLE(GLeglContext ctx,
+                                                            GLenum readTarget,
+                                                            GLenum writeTarget,
+                                                            GLintptr readOffset,
+                                                            GLintptr writeOffset,
+                                                            GLsizeiptr size);
+ANGLE_EXPORT void GL_APIENTRY CopyTexImage2DContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLint level,
+                                                         GLenum internalformat,
+                                                         GLint x,
+                                                         GLint y,
+                                                         GLsizei width,
+                                                         GLsizei height,
+                                                         GLint border);
+ANGLE_EXPORT void GL_APIENTRY CopyTexSubImage2DContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLint level,
+                                                            GLint xoffset,
+                                                            GLint yoffset,
+                                                            GLint x,
+                                                            GLint y,
+                                                            GLsizei width,
+                                                            GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY CopyTexSubImage3DContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLint level,
+                                                            GLint xoffset,
+                                                            GLint yoffset,
+                                                            GLint zoffset,
+                                                            GLint x,
+                                                            GLint y,
+                                                            GLsizei width,
+                                                            GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY CopyTexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLint level,
+                                                               GLint xoffset,
+                                                               GLint yoffset,
+                                                               GLint zoffset,
+                                                               GLint x,
+                                                               GLint y,
+                                                               GLsizei width,
+                                                               GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY CreateMemoryObjectsEXTContextANGLE(GLeglContext ctx,
+                                                                 GLsizei n,
+                                                                 GLuint *memoryObjects);
+ANGLE_EXPORT GLuint GL_APIENTRY CreateProgramContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT GLuint GL_APIENTRY CreateShaderContextANGLE(GLeglContext ctx, GLenum type);
+ANGLE_EXPORT GLuint GL_APIENTRY CreateShaderProgramvContextANGLE(GLeglContext ctx,
+                                                                 GLenum type,
+                                                                 GLsizei count,
+                                                                 const GLchar *const *strings);
+ANGLE_EXPORT void GL_APIENTRY CullFaceContextANGLE(GLeglContext ctx, GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY CurrentPaletteMatrixOESContextANGLE(GLeglContext ctx,
+                                                                  GLuint matrixpaletteindex);
+ANGLE_EXPORT void GL_APIENTRY DebugMessageCallbackKHRContextANGLE(GLeglContext ctx,
+                                                                  GLDEBUGPROCKHR callback,
+                                                                  const void *userParam);
+ANGLE_EXPORT void GL_APIENTRY DebugMessageControlKHRContextANGLE(GLeglContext ctx,
+                                                                 GLenum source,
+                                                                 GLenum type,
+                                                                 GLenum severity,
+                                                                 GLsizei count,
+                                                                 const GLuint *ids,
+                                                                 GLboolean enabled);
+ANGLE_EXPORT void GL_APIENTRY DebugMessageInsertKHRContextANGLE(GLeglContext ctx,
+                                                                GLenum source,
+                                                                GLenum type,
+                                                                GLuint id,
+                                                                GLenum severity,
+                                                                GLsizei length,
+                                                                const GLchar *buf);
+ANGLE_EXPORT void GL_APIENTRY DeleteBuffersContextANGLE(GLeglContext ctx,
+                                                        GLsizei n,
+                                                        const GLuint *buffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteFencesNVContextANGLE(GLeglContext ctx,
+                                                         GLsizei n,
+                                                         const GLuint *fences);
+ANGLE_EXPORT void GL_APIENTRY DeleteFramebuffersContextANGLE(GLeglContext ctx,
+                                                             GLsizei n,
+                                                             const GLuint *framebuffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteFramebuffersOESContextANGLE(GLeglContext ctx,
+                                                                GLsizei n,
+                                                                const GLuint *framebuffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteMemoryObjectsEXTContextANGLE(GLeglContext ctx,
+                                                                 GLsizei n,
+                                                                 const GLuint *memoryObjects);
+ANGLE_EXPORT void GL_APIENTRY DeleteProgramContextANGLE(GLeglContext ctx, GLuint program);
+ANGLE_EXPORT void GL_APIENTRY DeleteProgramPipelinesContextANGLE(GLeglContext ctx,
+                                                                 GLsizei n,
+                                                                 const GLuint *pipelines);
+ANGLE_EXPORT void GL_APIENTRY DeleteQueriesContextANGLE(GLeglContext ctx,
+                                                        GLsizei n,
+                                                        const GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY DeleteQueriesEXTContextANGLE(GLeglContext ctx,
+                                                           GLsizei n,
+                                                           const GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY DeleteRenderbuffersContextANGLE(GLeglContext ctx,
+                                                              GLsizei n,
+                                                              const GLuint *renderbuffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteRenderbuffersOESContextANGLE(GLeglContext ctx,
+                                                                 GLsizei n,
+                                                                 const GLuint *renderbuffers);
+ANGLE_EXPORT void GL_APIENTRY DeleteSamplersContextANGLE(GLeglContext ctx,
+                                                         GLsizei count,
+                                                         const GLuint *samplers);
+ANGLE_EXPORT void GL_APIENTRY DeleteSemaphoresEXTContextANGLE(GLeglContext ctx,
+                                                              GLsizei n,
+                                                              const GLuint *semaphores);
+ANGLE_EXPORT void GL_APIENTRY DeleteShaderContextANGLE(GLeglContext ctx, GLuint shader);
+ANGLE_EXPORT void GL_APIENTRY DeleteSyncContextANGLE(GLeglContext ctx, GLsync sync);
+ANGLE_EXPORT void GL_APIENTRY DeleteTexturesContextANGLE(GLeglContext ctx,
+                                                         GLsizei n,
+                                                         const GLuint *textures);
+ANGLE_EXPORT void GL_APIENTRY DeleteTransformFeedbacksContextANGLE(GLeglContext ctx,
+                                                                   GLsizei n,
+                                                                   const GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY DeleteVertexArraysContextANGLE(GLeglContext ctx,
+                                                             GLsizei n,
+                                                             const GLuint *arrays);
+ANGLE_EXPORT void GL_APIENTRY DeleteVertexArraysOESContextANGLE(GLeglContext ctx,
+                                                                GLsizei n,
+                                                                const GLuint *arrays);
+ANGLE_EXPORT void GL_APIENTRY DepthFuncContextANGLE(GLeglContext ctx, GLenum func);
+ANGLE_EXPORT void GL_APIENTRY DepthMaskContextANGLE(GLeglContext ctx, GLboolean flag);
+ANGLE_EXPORT void GL_APIENTRY DepthRangefContextANGLE(GLeglContext ctx, GLfloat n, GLfloat f);
+ANGLE_EXPORT void GL_APIENTRY DepthRangexContextANGLE(GLeglContext ctx, GLfixed n, GLfixed f);
+ANGLE_EXPORT void GL_APIENTRY DetachShaderContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLuint shader);
+ANGLE_EXPORT void GL_APIENTRY DisableContextANGLE(GLeglContext ctx, GLenum cap);
+ANGLE_EXPORT void GL_APIENTRY DisableClientStateContextANGLE(GLeglContext ctx, GLenum array);
+ANGLE_EXPORT void GL_APIENTRY DisableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index);
+ANGLE_EXPORT void GL_APIENTRY DiscardFramebufferEXTContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLsizei numAttachments,
+                                                                const GLenum *attachments);
+ANGLE_EXPORT void GL_APIENTRY DispatchComputeContextANGLE(GLeglContext ctx,
+                                                          GLuint num_groups_x,
+                                                          GLuint num_groups_y,
+                                                          GLuint num_groups_z);
+ANGLE_EXPORT void GL_APIENTRY DispatchComputeIndirectContextANGLE(GLeglContext ctx,
+                                                                  GLintptr indirect);
+ANGLE_EXPORT void GL_APIENTRY DrawArraysContextANGLE(GLeglContext ctx,
+                                                     GLenum mode,
+                                                     GLint first,
+                                                     GLsizei count);
+ANGLE_EXPORT void GL_APIENTRY DrawArraysIndirectContextANGLE(GLeglContext ctx,
+                                                             GLenum mode,
+                                                             const void *indirect);
+ANGLE_EXPORT void GL_APIENTRY DrawArraysInstancedContextANGLE(GLeglContext ctx,
+                                                              GLenum mode,
+                                                              GLint first,
+                                                              GLsizei count,
+                                                              GLsizei instancecount);
+ANGLE_EXPORT void GL_APIENTRY DrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLenum mode,
+                                                                   GLint first,
+                                                                   GLsizei count,
+                                                                   GLsizei primcount);
+ANGLE_EXPORT void GL_APIENTRY DrawArraysInstancedEXTContextANGLE(GLeglContext ctx,
+                                                                 GLenum mode,
+                                                                 GLint start,
+                                                                 GLsizei count,
+                                                                 GLsizei primcount);
+ANGLE_EXPORT void GL_APIENTRY DrawBuffersContextANGLE(GLeglContext ctx,
+                                                      GLsizei n,
+                                                      const GLenum *bufs);
+ANGLE_EXPORT void GL_APIENTRY DrawBuffersEXTContextANGLE(GLeglContext ctx,
+                                                         GLsizei n,
+                                                         const GLenum *bufs);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsContextANGLE(GLeglContext ctx,
+                                                       GLenum mode,
+                                                       GLsizei count,
+                                                       GLenum type,
+                                                       const void *indices);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsIndirectContextANGLE(GLeglContext ctx,
+                                                               GLenum mode,
+                                                               GLenum type,
+                                                               const void *indirect);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsInstancedContextANGLE(GLeglContext ctx,
+                                                                GLenum mode,
+                                                                GLsizei count,
+                                                                GLenum type,
+                                                                const void *indices,
+                                                                GLsizei instancecount);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                                     GLenum mode,
+                                                                     GLsizei count,
+                                                                     GLenum type,
+                                                                     const void *indices,
+                                                                     GLsizei primcount);
+ANGLE_EXPORT void GL_APIENTRY DrawElementsInstancedEXTContextANGLE(GLeglContext ctx,
+                                                                   GLenum mode,
+                                                                   GLsizei count,
+                                                                   GLenum type,
+                                                                   const void *indices,
+                                                                   GLsizei primcount);
+ANGLE_EXPORT void GL_APIENTRY DrawRangeElementsContextANGLE(GLeglContext ctx,
+                                                            GLenum mode,
+                                                            GLuint start,
+                                                            GLuint end,
+                                                            GLsizei count,
+                                                            GLenum type,
+                                                            const void *indices);
+ANGLE_EXPORT void GL_APIENTRY DrawTexfOESContextANGLE(GLeglContext ctx,
+                                                      GLfloat x,
+                                                      GLfloat y,
+                                                      GLfloat z,
+                                                      GLfloat width,
+                                                      GLfloat height);
+ANGLE_EXPORT void GL_APIENTRY DrawTexfvOESContextANGLE(GLeglContext ctx, const GLfloat *coords);
+ANGLE_EXPORT void GL_APIENTRY
+DrawTexiOESContextANGLE(GLeglContext ctx, GLint x, GLint y, GLint z, GLint width, GLint height);
+ANGLE_EXPORT void GL_APIENTRY DrawTexivOESContextANGLE(GLeglContext ctx, const GLint *coords);
+ANGLE_EXPORT void GL_APIENTRY DrawTexsOESContextANGLE(GLeglContext ctx,
+                                                      GLshort x,
+                                                      GLshort y,
+                                                      GLshort z,
+                                                      GLshort width,
+                                                      GLshort height);
+ANGLE_EXPORT void GL_APIENTRY DrawTexsvOESContextANGLE(GLeglContext ctx, const GLshort *coords);
+ANGLE_EXPORT void GL_APIENTRY DrawTexxOESContextANGLE(GLeglContext ctx,
+                                                      GLfixed x,
+                                                      GLfixed y,
+                                                      GLfixed z,
+                                                      GLfixed width,
+                                                      GLfixed height);
+ANGLE_EXPORT void GL_APIENTRY DrawTexxvOESContextANGLE(GLeglContext ctx, const GLfixed *coords);
+ANGLE_EXPORT void GL_APIENTRY EGLImageTargetRenderbufferStorageOESContextANGLE(GLeglContext ctx,
+                                                                               GLenum target,
+                                                                               GLeglImageOES image);
+ANGLE_EXPORT void GL_APIENTRY EGLImageTargetTexture2DOESContextANGLE(GLeglContext ctx,
+                                                                     GLenum target,
+                                                                     GLeglImageOES image);
+ANGLE_EXPORT void GL_APIENTRY EnableContextANGLE(GLeglContext ctx, GLenum cap);
+ANGLE_EXPORT void GL_APIENTRY EnableClientStateContextANGLE(GLeglContext ctx, GLenum array);
+ANGLE_EXPORT void GL_APIENTRY EnableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index);
+ANGLE_EXPORT void GL_APIENTRY EndQueryContextANGLE(GLeglContext ctx, GLenum target);
+ANGLE_EXPORT void GL_APIENTRY EndQueryEXTContextANGLE(GLeglContext ctx, GLenum target);
+ANGLE_EXPORT void GL_APIENTRY EndTransformFeedbackContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT GLsync GL_APIENTRY FenceSyncContextANGLE(GLeglContext ctx,
+                                                      GLenum condition,
+                                                      GLbitfield flags);
+ANGLE_EXPORT void GL_APIENTRY FinishContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY FinishFenceNVContextANGLE(GLeglContext ctx, GLuint fence);
+ANGLE_EXPORT void GL_APIENTRY FlushContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY FlushMappedBufferRangeContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLintptr offset,
+                                                                 GLsizeiptr length);
+ANGLE_EXPORT void GL_APIENTRY FlushMappedBufferRangeEXTContextANGLE(GLeglContext ctx,
+                                                                    GLenum target,
+                                                                    GLintptr offset,
+                                                                    GLsizeiptr length);
+ANGLE_EXPORT void GL_APIENTRY FogfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY FogfvContextANGLE(GLeglContext ctx,
+                                                GLenum pname,
+                                                const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY FogxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY FogxvContextANGLE(GLeglContext ctx,
+                                                GLenum pname,
+                                                const GLfixed *param);
+ANGLE_EXPORT void GL_APIENTRY FramebufferParameteriContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLenum pname,
+                                                                GLint param);
+ANGLE_EXPORT void GL_APIENTRY FramebufferRenderbufferContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLenum attachment,
+                                                                  GLenum renderbuffertarget,
+                                                                  GLuint renderbuffer);
+ANGLE_EXPORT void GL_APIENTRY FramebufferRenderbufferOESContextANGLE(GLeglContext ctx,
+                                                                     GLenum target,
+                                                                     GLenum attachment,
+                                                                     GLenum renderbuffertarget,
+                                                                     GLuint renderbuffer);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTexture2DContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLenum attachment,
+                                                               GLenum textarget,
+                                                               GLuint texture,
+                                                               GLint level);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTexture2DOESContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLenum attachment,
+                                                                  GLenum textarget,
+                                                                  GLuint texture,
+                                                                  GLint level);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTexture3DOESContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLenum attachment,
+                                                                  GLenum textarget,
+                                                                  GLuint texture,
+                                                                  GLint level,
+                                                                  GLint zoffset);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTextureEXTContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLenum attachment,
+                                                                GLuint texture,
+                                                                GLint level);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTextureLayerContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLenum attachment,
+                                                                  GLuint texture,
+                                                                  GLint level,
+                                                                  GLint layer);
+ANGLE_EXPORT void GL_APIENTRY FramebufferTextureMultiviewOVRContextANGLE(GLeglContext ctx,
+                                                                         GLenum target,
+                                                                         GLenum attachment,
+                                                                         GLuint texture,
+                                                                         GLint level,
+                                                                         GLint baseViewIndex,
+                                                                         GLsizei numViews);
+ANGLE_EXPORT void GL_APIENTRY FrontFaceContextANGLE(GLeglContext ctx, GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY FrustumfContextANGLE(GLeglContext ctx,
+                                                   GLfloat l,
+                                                   GLfloat r,
+                                                   GLfloat b,
+                                                   GLfloat t,
+                                                   GLfloat n,
+                                                   GLfloat f);
+ANGLE_EXPORT void GL_APIENTRY FrustumxContextANGLE(GLeglContext ctx,
+                                                   GLfixed l,
+                                                   GLfixed r,
+                                                   GLfixed b,
+                                                   GLfixed t,
+                                                   GLfixed n,
+                                                   GLfixed f);
+ANGLE_EXPORT void GL_APIENTRY GenBuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *buffers);
+ANGLE_EXPORT void GL_APIENTRY GenFencesNVContextANGLE(GLeglContext ctx, GLsizei n, GLuint *fences);
+ANGLE_EXPORT void GL_APIENTRY GenFramebuffersContextANGLE(GLeglContext ctx,
+                                                          GLsizei n,
+                                                          GLuint *framebuffers);
+ANGLE_EXPORT void GL_APIENTRY GenFramebuffersOESContextANGLE(GLeglContext ctx,
+                                                             GLsizei n,
+                                                             GLuint *framebuffers);
+ANGLE_EXPORT void GL_APIENTRY GenProgramPipelinesContextANGLE(GLeglContext ctx,
+                                                              GLsizei n,
+                                                              GLuint *pipelines);
+ANGLE_EXPORT void GL_APIENTRY GenQueriesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY GenQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY GenRenderbuffersContextANGLE(GLeglContext ctx,
+                                                           GLsizei n,
+                                                           GLuint *renderbuffers);
+ANGLE_EXPORT void GL_APIENTRY GenRenderbuffersOESContextANGLE(GLeglContext ctx,
+                                                              GLsizei n,
+                                                              GLuint *renderbuffers);
+ANGLE_EXPORT void GL_APIENTRY GenSamplersContextANGLE(GLeglContext ctx,
+                                                      GLsizei count,
+                                                      GLuint *samplers);
+ANGLE_EXPORT void GL_APIENTRY GenSemaphoresEXTContextANGLE(GLeglContext ctx,
+                                                           GLsizei n,
+                                                           GLuint *semaphores);
+ANGLE_EXPORT void GL_APIENTRY GenTexturesContextANGLE(GLeglContext ctx,
+                                                      GLsizei n,
+                                                      GLuint *textures);
+ANGLE_EXPORT void GL_APIENTRY GenTransformFeedbacksContextANGLE(GLeglContext ctx,
+                                                                GLsizei n,
+                                                                GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY GenVertexArraysContextANGLE(GLeglContext ctx,
+                                                          GLsizei n,
+                                                          GLuint *arrays);
+ANGLE_EXPORT void GL_APIENTRY GenVertexArraysOESContextANGLE(GLeglContext ctx,
+                                                             GLsizei n,
+                                                             GLuint *arrays);
+ANGLE_EXPORT void GL_APIENTRY GenerateMipmapContextANGLE(GLeglContext ctx, GLenum target);
+ANGLE_EXPORT void GL_APIENTRY GenerateMipmapOESContextANGLE(GLeglContext ctx, GLenum target);
+ANGLE_EXPORT void GL_APIENTRY GetActiveAttribContextANGLE(GLeglContext ctx,
+                                                          GLuint program,
+                                                          GLuint index,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLint *size,
+                                                          GLenum *type,
+                                                          GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLuint index,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *size,
+                                                           GLenum *type,
+                                                           GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockNameContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLuint uniformBlockIndex,
+                                                                    GLsizei bufSize,
+                                                                    GLsizei *length,
+                                                                    GLchar *uniformBlockName);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockivContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLuint uniformBlockIndex,
+                                                                  GLenum pname,
+                                                                  GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformsivContextANGLE(GLeglContext ctx,
+                                                              GLuint program,
+                                                              GLsizei uniformCount,
+                                                              const GLuint *uniformIndices,
+                                                              GLenum pname,
+                                                              GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetAttachedShadersContextANGLE(GLeglContext ctx,
+                                                             GLuint program,
+                                                             GLsizei maxCount,
+                                                             GLsizei *count,
+                                                             GLuint *shaders);
+ANGLE_EXPORT GLint GL_APIENTRY GetAttribLocationContextANGLE(GLeglContext ctx,
+                                                             GLuint program,
+                                                             const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetBooleani_vContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLuint index,
+                                                        GLboolean *data);
+ANGLE_EXPORT void GL_APIENTRY GetBooleanvContextANGLE(GLeglContext ctx,
+                                                      GLenum pname,
+                                                      GLboolean *data);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameteri64vContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLenum pname,
+                                                                 GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameterivContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLenum pname,
+                                                               GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferPointervContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum pname,
+                                                            void **params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferPointervOESContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLenum pname,
+                                                               void **params);
+ANGLE_EXPORT void GL_APIENTRY GetClipPlanefContextANGLE(GLeglContext ctx,
+                                                        GLenum plane,
+                                                        GLfloat *equation);
+ANGLE_EXPORT void GL_APIENTRY GetClipPlanexContextANGLE(GLeglContext ctx,
+                                                        GLenum plane,
+                                                        GLfixed *equation);
+ANGLE_EXPORT GLuint GL_APIENTRY GetDebugMessageLogKHRContextANGLE(GLeglContext ctx,
+                                                                  GLuint count,
+                                                                  GLsizei bufSize,
+                                                                  GLenum *sources,
+                                                                  GLenum *types,
+                                                                  GLuint *ids,
+                                                                  GLenum *severities,
+                                                                  GLsizei *lengths,
+                                                                  GLchar *messageLog);
+ANGLE_EXPORT GLenum GL_APIENTRY GetErrorContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY GetFenceivNVContextANGLE(GLeglContext ctx,
+                                                       GLuint fence,
+                                                       GLenum pname,
+                                                       GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetFixedvContextANGLE(GLeglContext ctx,
+                                                    GLenum pname,
+                                                    GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetFloatvContextANGLE(GLeglContext ctx, GLenum pname, GLfloat *data);
+ANGLE_EXPORT GLint GL_APIENTRY GetFragDataIndexEXTContextANGLE(GLeglContext ctx,
+                                                               GLuint program,
+                                                               const GLchar *name);
+ANGLE_EXPORT GLint GL_APIENTRY GetFragDataLocationContextANGLE(GLeglContext ctx,
+                                                               GLuint program,
+                                                               const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferAttachmentParameterivContextANGLE(GLeglContext ctx,
+                                                                              GLenum target,
+                                                                              GLenum attachment,
+                                                                              GLenum pname,
+                                                                              GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferAttachmentParameterivOESContextANGLE(GLeglContext ctx,
+                                                                                 GLenum target,
+                                                                                 GLenum attachment,
+                                                                                 GLenum pname,
+                                                                                 GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferParameterivContextANGLE(GLeglContext ctx,
+                                                                    GLenum target,
+                                                                    GLenum pname,
+                                                                    GLint *params);
+ANGLE_EXPORT GLenum GL_APIENTRY GetGraphicsResetStatusEXTContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64i_vContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLuint index,
+                                                          GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64vContextANGLE(GLeglContext ctx,
+                                                        GLenum pname,
+                                                        GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetIntegeri_vContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLuint index,
+                                                        GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetIntegervContextANGLE(GLeglContext ctx, GLenum pname, GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetInternalformativContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLenum internalformat,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetLightfvContextANGLE(GLeglContext ctx,
+                                                     GLenum light,
+                                                     GLenum pname,
+                                                     GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetLightxvContextANGLE(GLeglContext ctx,
+                                                     GLenum light,
+                                                     GLenum pname,
+                                                     GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetMaterialfvContextANGLE(GLeglContext ctx,
+                                                        GLenum face,
+                                                        GLenum pname,
+                                                        GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetMaterialxvContextANGLE(GLeglContext ctx,
+                                                        GLenum face,
+                                                        GLenum pname,
+                                                        GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetMemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
+                                                                        GLuint memoryObject,
+                                                                        GLenum pname,
+                                                                        GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetMultisamplefvContextANGLE(GLeglContext ctx,
+                                                           GLenum pname,
+                                                           GLuint index,
+                                                           GLfloat *val);
+ANGLE_EXPORT void GL_APIENTRY GetObjectLabelKHRContextANGLE(GLeglContext ctx,
+                                                            GLenum identifier,
+                                                            GLuint name,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLchar *label);
+ANGLE_EXPORT void GL_APIENTRY GetObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
+                                                               const void *ptr,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLchar *label);
+ANGLE_EXPORT void GL_APIENTRY GetPointervContextANGLE(GLeglContext ctx,
+                                                      GLenum pname,
+                                                      void **params);
+ANGLE_EXPORT void GL_APIENTRY GetPointervKHRContextANGLE(GLeglContext ctx,
+                                                         GLenum pname,
+                                                         void **params);
+ANGLE_EXPORT void GL_APIENTRY GetProgramBinaryContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLenum *binaryFormat,
+                                                           void *binary);
+ANGLE_EXPORT void GL_APIENTRY GetProgramBinaryOESContextANGLE(GLeglContext ctx,
+                                                              GLuint program,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLenum *binaryFormat,
+                                                              void *binary);
+ANGLE_EXPORT void GL_APIENTRY GetProgramInfoLogContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLchar *infoLog);
+ANGLE_EXPORT void GL_APIENTRY GetProgramInterfaceivContextANGLE(GLeglContext ctx,
+                                                                GLuint program,
+                                                                GLenum programInterface,
+                                                                GLenum pname,
+                                                                GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetProgramPipelineInfoLogContextANGLE(GLeglContext ctx,
+                                                                    GLuint pipeline,
+                                                                    GLsizei bufSize,
+                                                                    GLsizei *length,
+                                                                    GLchar *infoLog);
+ANGLE_EXPORT void GL_APIENTRY GetProgramPipelineivContextANGLE(GLeglContext ctx,
+                                                               GLuint pipeline,
+                                                               GLenum pname,
+                                                               GLint *params);
+ANGLE_EXPORT GLuint GL_APIENTRY GetProgramResourceIndexContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLenum programInterface,
+                                                                    const GLchar *name);
+ANGLE_EXPORT GLint GL_APIENTRY GetProgramResourceLocationContextANGLE(GLeglContext ctx,
+                                                                      GLuint program,
+                                                                      GLenum programInterface,
+                                                                      const GLchar *name);
+ANGLE_EXPORT GLint GL_APIENTRY
+GetProgramResourceLocationIndexEXTContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLenum programInterface,
+                                               const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetProgramResourceNameContextANGLE(GLeglContext ctx,
+                                                                 GLuint program,
+                                                                 GLenum programInterface,
+                                                                 GLuint index,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetProgramResourceivContextANGLE(GLeglContext ctx,
+                                                               GLuint program,
+                                                               GLenum programInterface,
+                                                               GLuint index,
+                                                               GLsizei propCount,
+                                                               const GLenum *props,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetProgramivContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLenum pname,
+                                                       GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjecti64vEXTContextANGLE(GLeglContext ctx,
+                                                                GLuint id,
+                                                                GLenum pname,
+                                                                GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectivEXTContextANGLE(GLeglContext ctx,
+                                                              GLuint id,
+                                                              GLenum pname,
+                                                              GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectui64vEXTContextANGLE(GLeglContext ctx,
+                                                                 GLuint id,
+                                                                 GLenum pname,
+                                                                 GLuint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuivContextANGLE(GLeglContext ctx,
+                                                            GLuint id,
+                                                            GLenum pname,
+                                                            GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuivEXTContextANGLE(GLeglContext ctx,
+                                                               GLuint id,
+                                                               GLenum pname,
+                                                               GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryivContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum pname,
+                                                     GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryivEXTContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetRenderbufferParameterivContextANGLE(GLeglContext ctx,
+                                                                     GLenum target,
+                                                                     GLenum pname,
+                                                                     GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetRenderbufferParameterivOESContextANGLE(GLeglContext ctx,
+                                                                        GLenum target,
+                                                                        GLenum pname,
+                                                                        GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIivOESContextANGLE(GLeglContext ctx,
+                                                                    GLuint sampler,
+                                                                    GLenum pname,
+                                                                    GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                                     GLuint sampler,
+                                                                     GLenum pname,
+                                                                     GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterfvContextANGLE(GLeglContext ctx,
+                                                                GLuint sampler,
+                                                                GLenum pname,
+                                                                GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterivContextANGLE(GLeglContext ctx,
+                                                                GLuint sampler,
+                                                                GLenum pname,
+                                                                GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
+                                                                        GLuint semaphore,
+                                                                        GLenum pname,
+                                                                        GLuint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetShaderInfoLogContextANGLE(GLeglContext ctx,
+                                                           GLuint shader,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLchar *infoLog);
+ANGLE_EXPORT void GL_APIENTRY GetShaderPrecisionFormatContextANGLE(GLeglContext ctx,
+                                                                   GLenum shadertype,
+                                                                   GLenum precisiontype,
+                                                                   GLint *range,
+                                                                   GLint *precision);
+ANGLE_EXPORT void GL_APIENTRY GetShaderSourceContextANGLE(GLeglContext ctx,
+                                                          GLuint shader,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLchar *source);
+ANGLE_EXPORT void GL_APIENTRY GetShaderivContextANGLE(GLeglContext ctx,
+                                                      GLuint shader,
+                                                      GLenum pname,
+                                                      GLint *params);
+ANGLE_EXPORT const GLubyte *GL_APIENTRY GetStringContextANGLE(GLeglContext ctx, GLenum name);
+ANGLE_EXPORT const GLubyte *GL_APIENTRY GetStringiContextANGLE(GLeglContext ctx,
+                                                               GLenum name,
+                                                               GLuint index);
+ANGLE_EXPORT void GL_APIENTRY GetSyncivContextANGLE(GLeglContext ctx,
+                                                    GLsync sync,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *values);
+ANGLE_EXPORT void GL_APIENTRY GetTexEnvfvContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLenum pname,
+                                                      GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexEnvivContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLenum pname,
+                                                      GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexEnvxvContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLenum pname,
+                                                      GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexGenfvOESContextANGLE(GLeglContext ctx,
+                                                         GLenum coord,
+                                                         GLenum pname,
+                                                         GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexGenivOESContextANGLE(GLeglContext ctx,
+                                                         GLenum coord,
+                                                         GLenum pname,
+                                                         GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexGenxvOESContextANGLE(GLeglContext ctx,
+                                                         GLenum coord,
+                                                         GLenum pname,
+                                                         GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfvContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLint level,
+                                                                 GLenum pname,
+                                                                 GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterivContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLint level,
+                                                                 GLenum pname,
+                                                                 GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterIivOESContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLenum pname,
+                                                                GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLenum pname,
+                                                                 GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterfvContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum pname,
+                                                            GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterivContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum pname,
+                                                            GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterxvContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum pname,
+                                                            GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY GetTransformFeedbackVaryingContextANGLE(GLeglContext ctx,
+                                                                      GLuint program,
+                                                                      GLuint index,
+                                                                      GLsizei bufSize,
+                                                                      GLsizei *length,
+                                                                      GLsizei *size,
+                                                                      GLenum *type,
+                                                                      GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetTranslatedShaderSourceANGLEContextANGLE(GLeglContext ctx,
+                                                                         GLuint shader,
+                                                                         GLsizei bufsize,
+                                                                         GLsizei *length,
+                                                                         GLchar *source);
+ANGLE_EXPORT GLuint GL_APIENTRY GetUniformBlockIndexContextANGLE(GLeglContext ctx,
+                                                                 GLuint program,
+                                                                 const GLchar *uniformBlockName);
+ANGLE_EXPORT void GL_APIENTRY GetUniformIndicesContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLsizei uniformCount,
+                                                            const GLchar *const *uniformNames,
+                                                            GLuint *uniformIndices);
+ANGLE_EXPORT GLint GL_APIENTRY GetUniformLocationContextANGLE(GLeglContext ctx,
+                                                              GLuint program,
+                                                              const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetUniformfvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformivContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformuivContextANGLE(GLeglContext ctx,
+                                                        GLuint program,
+                                                        GLint location,
+                                                        GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetUnsignedBytevEXTContextANGLE(GLeglContext ctx,
+                                                              GLenum pname,
+                                                              GLubyte *data);
+ANGLE_EXPORT void GL_APIENTRY GetUnsignedBytei_vEXTContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLuint index,
+                                                                GLubyte *data);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIivContextANGLE(GLeglContext ctx,
+                                                             GLuint index,
+                                                             GLenum pname,
+                                                             GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIuivContextANGLE(GLeglContext ctx,
+                                                              GLuint index,
+                                                              GLenum pname,
+                                                              GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribPointervContextANGLE(GLeglContext ctx,
+                                                                  GLuint index,
+                                                                  GLenum pname,
+                                                                  void **pointer);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribfvContextANGLE(GLeglContext ctx,
+                                                            GLuint index,
+                                                            GLenum pname,
+                                                            GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribivContextANGLE(GLeglContext ctx,
+                                                            GLuint index,
+                                                            GLenum pname,
+                                                            GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformfvEXTContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLsizei bufSize,
+                                                           GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformivEXTContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLsizei bufSize,
+                                                           GLint *params);
+ANGLE_EXPORT void GL_APIENTRY HintContextANGLE(GLeglContext ctx, GLenum target, GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY ImportMemoryFdEXTContextANGLE(GLeglContext ctx,
+                                                            GLuint memory,
+                                                            GLuint64 size,
+                                                            GLenum handleType,
+                                                            GLint fd);
+ANGLE_EXPORT void GL_APIENTRY ImportSemaphoreFdEXTContextANGLE(GLeglContext ctx,
+                                                               GLuint semaphore,
+                                                               GLenum handleType,
+                                                               GLint fd);
+ANGLE_EXPORT void GL_APIENTRY InsertEventMarkerEXTContextANGLE(GLeglContext ctx,
+                                                               GLsizei length,
+                                                               const GLchar *marker);
+ANGLE_EXPORT void GL_APIENTRY InvalidateFramebufferContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLsizei numAttachments,
+                                                                const GLenum *attachments);
+ANGLE_EXPORT void GL_APIENTRY InvalidateSubFramebufferContextANGLE(GLeglContext ctx,
+                                                                   GLenum target,
+                                                                   GLsizei numAttachments,
+                                                                   const GLenum *attachments,
+                                                                   GLint x,
+                                                                   GLint y,
+                                                                   GLsizei width,
+                                                                   GLsizei height);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsBufferContextANGLE(GLeglContext ctx, GLuint buffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsEnabledContextANGLE(GLeglContext ctx, GLenum cap);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsFenceNVContextANGLE(GLeglContext ctx, GLuint fence);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsFramebufferContextANGLE(GLeglContext ctx, GLuint framebuffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsFramebufferOESContextANGLE(GLeglContext ctx,
+                                                                GLuint framebuffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsMemoryObjectEXTContextANGLE(GLeglContext ctx,
+                                                                 GLuint memoryObject);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsProgramContextANGLE(GLeglContext ctx, GLuint program);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsQueryContextANGLE(GLeglContext ctx, GLuint id);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsQueryEXTContextANGLE(GLeglContext ctx, GLuint id);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsRenderbufferContextANGLE(GLeglContext ctx,
+                                                              GLuint renderbuffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsRenderbufferOESContextANGLE(GLeglContext ctx,
+                                                                 GLuint renderbuffer);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsSemaphoreEXTContextANGLE(GLeglContext ctx, GLuint semaphore);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsSamplerContextANGLE(GLeglContext ctx, GLuint sampler);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsShaderContextANGLE(GLeglContext ctx, GLuint shader);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsSyncContextANGLE(GLeglContext ctx, GLsync sync);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsTextureContextANGLE(GLeglContext ctx, GLuint texture);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsTransformFeedbackContextANGLE(GLeglContext ctx, GLuint id);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsVertexArrayContextANGLE(GLeglContext ctx, GLuint array);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array);
+ANGLE_EXPORT void GL_APIENTRY LightModelfContextANGLE(GLeglContext ctx,
+                                                      GLenum pname,
+                                                      GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY LightModelfvContextANGLE(GLeglContext ctx,
+                                                       GLenum pname,
+                                                       const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY LightModelxContextANGLE(GLeglContext ctx,
+                                                      GLenum pname,
+                                                      GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY LightModelxvContextANGLE(GLeglContext ctx,
+                                                       GLenum pname,
+                                                       const GLfixed *param);
+ANGLE_EXPORT void GL_APIENTRY LightfContextANGLE(GLeglContext ctx,
+                                                 GLenum light,
+                                                 GLenum pname,
+                                                 GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY LightfvContextANGLE(GLeglContext ctx,
+                                                  GLenum light,
+                                                  GLenum pname,
+                                                  const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY LightxContextANGLE(GLeglContext ctx,
+                                                 GLenum light,
+                                                 GLenum pname,
+                                                 GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY LightxvContextANGLE(GLeglContext ctx,
+                                                  GLenum light,
+                                                  GLenum pname,
+                                                  const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY LineWidthContextANGLE(GLeglContext ctx, GLfloat width);
+ANGLE_EXPORT void GL_APIENTRY LineWidthxContextANGLE(GLeglContext ctx, GLfixed width);
+ANGLE_EXPORT void GL_APIENTRY LinkProgramContextANGLE(GLeglContext ctx, GLuint program);
+ANGLE_EXPORT void GL_APIENTRY LoadIdentityContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY LoadMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m);
+ANGLE_EXPORT void GL_APIENTRY LoadMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m);
+ANGLE_EXPORT void GL_APIENTRY LoadPaletteFromModelViewMatrixOESContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY LogicOpContextANGLE(GLeglContext ctx, GLenum opcode);
+ANGLE_EXPORT void *GL_APIENTRY MapBufferOESContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLenum access);
+ANGLE_EXPORT void *GL_APIENTRY MapBufferRangeContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLintptr offset,
+                                                          GLsizeiptr length,
+                                                          GLbitfield access);
+ANGLE_EXPORT void *GL_APIENTRY MapBufferRangeEXTContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLintptr offset,
+                                                             GLsizeiptr length,
+                                                             GLbitfield access);
+ANGLE_EXPORT void GL_APIENTRY MaterialfContextANGLE(GLeglContext ctx,
+                                                    GLenum face,
+                                                    GLenum pname,
+                                                    GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY MaterialfvContextANGLE(GLeglContext ctx,
+                                                     GLenum face,
+                                                     GLenum pname,
+                                                     const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY MaterialxContextANGLE(GLeglContext ctx,
+                                                    GLenum face,
+                                                    GLenum pname,
+                                                    GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY MaterialxvContextANGLE(GLeglContext ctx,
+                                                     GLenum face,
+                                                     GLenum pname,
+                                                     const GLfixed *param);
+ANGLE_EXPORT void GL_APIENTRY MatrixIndexPointerOESContextANGLE(GLeglContext ctx,
+                                                                GLint size,
+                                                                GLenum type,
+                                                                GLsizei stride,
+                                                                const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY MatrixModeContextANGLE(GLeglContext ctx, GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY MaxShaderCompilerThreadsKHRContextANGLE(GLeglContext ctx,
+                                                                      GLuint count);
+ANGLE_EXPORT void GL_APIENTRY MemoryBarrierContextANGLE(GLeglContext ctx, GLbitfield barriers);
+ANGLE_EXPORT void GL_APIENTRY MemoryBarrierByRegionContextANGLE(GLeglContext ctx,
+                                                                GLbitfield barriers);
+ANGLE_EXPORT void GL_APIENTRY MemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
+                                                                     GLuint memoryObject,
+                                                                     GLenum pname,
+                                                                     const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY MultMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m);
+ANGLE_EXPORT void GL_APIENTRY MultMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m);
+ANGLE_EXPORT void GL_APIENTRY MultiTexCoord4fContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLfloat s,
+                                                          GLfloat t,
+                                                          GLfloat r,
+                                                          GLfloat q);
+ANGLE_EXPORT void GL_APIENTRY MultiTexCoord4xContextANGLE(GLeglContext ctx,
+                                                          GLenum texture,
+                                                          GLfixed s,
+                                                          GLfixed t,
+                                                          GLfixed r,
+                                                          GLfixed q);
+ANGLE_EXPORT void GL_APIENTRY Normal3fContextANGLE(GLeglContext ctx,
+                                                   GLfloat nx,
+                                                   GLfloat ny,
+                                                   GLfloat nz);
+ANGLE_EXPORT void GL_APIENTRY Normal3xContextANGLE(GLeglContext ctx,
+                                                   GLfixed nx,
+                                                   GLfixed ny,
+                                                   GLfixed nz);
+ANGLE_EXPORT void GL_APIENTRY NormalPointerContextANGLE(GLeglContext ctx,
+                                                        GLenum type,
+                                                        GLsizei stride,
+                                                        const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY ObjectLabelKHRContextANGLE(GLeglContext ctx,
+                                                         GLenum identifier,
+                                                         GLuint name,
+                                                         GLsizei length,
+                                                         const GLchar *label);
+ANGLE_EXPORT void GL_APIENTRY ObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
+                                                            const void *ptr,
+                                                            GLsizei length,
+                                                            const GLchar *label);
+ANGLE_EXPORT void GL_APIENTRY OrthofContextANGLE(GLeglContext ctx,
+                                                 GLfloat l,
+                                                 GLfloat r,
+                                                 GLfloat b,
+                                                 GLfloat t,
+                                                 GLfloat n,
+                                                 GLfloat f);
+ANGLE_EXPORT void GL_APIENTRY OrthoxContextANGLE(GLeglContext ctx,
+                                                 GLfixed l,
+                                                 GLfixed r,
+                                                 GLfixed b,
+                                                 GLfixed t,
+                                                 GLfixed n,
+                                                 GLfixed f);
+ANGLE_EXPORT void GL_APIENTRY PauseTransformFeedbackContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY PixelStoreiContextANGLE(GLeglContext ctx, GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY PointParameterfContextANGLE(GLeglContext ctx,
+                                                          GLenum pname,
+                                                          GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY PointParameterfvContextANGLE(GLeglContext ctx,
+                                                           GLenum pname,
+                                                           const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY PointParameterxContextANGLE(GLeglContext ctx,
+                                                          GLenum pname,
+                                                          GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY PointParameterxvContextANGLE(GLeglContext ctx,
+                                                           GLenum pname,
+                                                           const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY PointSizeContextANGLE(GLeglContext ctx, GLfloat size);
+ANGLE_EXPORT void GL_APIENTRY PointSizePointerOESContextANGLE(GLeglContext ctx,
+                                                              GLenum type,
+                                                              GLsizei stride,
+                                                              const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY PointSizexContextANGLE(GLeglContext ctx, GLfixed size);
+ANGLE_EXPORT void GL_APIENTRY PolygonOffsetContextANGLE(GLeglContext ctx,
+                                                        GLfloat factor,
+                                                        GLfloat units);
+ANGLE_EXPORT void GL_APIENTRY PolygonOffsetxContextANGLE(GLeglContext ctx,
+                                                         GLfixed factor,
+                                                         GLfixed units);
+ANGLE_EXPORT void GL_APIENTRY PopDebugGroupKHRContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY PopGroupMarkerEXTContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY PopMatrixContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY ProgramBinaryContextANGLE(GLeglContext ctx,
+                                                        GLuint program,
+                                                        GLenum binaryFormat,
+                                                        const void *binary,
+                                                        GLsizei length);
+ANGLE_EXPORT void GL_APIENTRY ProgramBinaryOESContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLenum binaryFormat,
+                                                           const void *binary,
+                                                           GLint length);
+ANGLE_EXPORT void GL_APIENTRY ProgramParameteriContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLenum pname,
+                                                            GLint value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1fContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLfloat v0);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1fvContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLsizei count,
+                                                            const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1iContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLint v0);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1ivContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLsizei count,
+                                                            const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1uiContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLuint v0);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1uivContextANGLE(GLeglContext ctx,
+                                                             GLuint program,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2fContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLfloat v0,
+                                                           GLfloat v1);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2fvContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLsizei count,
+                                                            const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform2iContextANGLE(GLeglContext ctx, GLuint program, GLint location, GLint v0, GLint v1);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2ivContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLsizei count,
+                                                            const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2uiContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLuint v0,
+                                                            GLuint v1);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2uivContextANGLE(GLeglContext ctx,
+                                                             GLuint program,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3fContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLfloat v0,
+                                                           GLfloat v1,
+                                                           GLfloat v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3fvContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLsizei count,
+                                                            const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3iContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLint v0,
+                                                           GLint v1,
+                                                           GLint v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3ivContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLsizei count,
+                                                            const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3uiContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLuint v0,
+                                                            GLuint v1,
+                                                            GLuint v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3uivContextANGLE(GLeglContext ctx,
+                                                             GLuint program,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4fContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLfloat v0,
+                                                           GLfloat v1,
+                                                           GLfloat v2,
+                                                           GLfloat v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4fvContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLsizei count,
+                                                            const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4iContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           GLint v0,
+                                                           GLint v1,
+                                                           GLint v2,
+                                                           GLint v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4ivContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLsizei count,
+                                                            const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4uiContextANGLE(GLeglContext ctx,
+                                                            GLuint program,
+                                                            GLint location,
+                                                            GLuint v0,
+                                                            GLuint v1,
+                                                            GLuint v2,
+                                                            GLuint v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4uivContextANGLE(GLeglContext ctx,
+                                                             GLuint program,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2fvContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLint location,
+                                                                  GLsizei count,
+                                                                  GLboolean transpose,
+                                                                  const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2x3fvContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLint location,
+                                                                    GLsizei count,
+                                                                    GLboolean transpose,
+                                                                    const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2x4fvContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLint location,
+                                                                    GLsizei count,
+                                                                    GLboolean transpose,
+                                                                    const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3fvContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLint location,
+                                                                  GLsizei count,
+                                                                  GLboolean transpose,
+                                                                  const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3x2fvContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLint location,
+                                                                    GLsizei count,
+                                                                    GLboolean transpose,
+                                                                    const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3x4fvContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLint location,
+                                                                    GLsizei count,
+                                                                    GLboolean transpose,
+                                                                    const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4fvContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLint location,
+                                                                  GLsizei count,
+                                                                  GLboolean transpose,
+                                                                  const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4x2fvContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLint location,
+                                                                    GLsizei count,
+                                                                    GLboolean transpose,
+                                                                    const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4x3fvContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLint location,
+                                                                    GLsizei count,
+                                                                    GLboolean transpose,
+                                                                    const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY PushDebugGroupKHRContextANGLE(GLeglContext ctx,
+                                                            GLenum source,
+                                                            GLuint id,
+                                                            GLsizei length,
+                                                            const GLchar *message);
+ANGLE_EXPORT void GL_APIENTRY PushGroupMarkerEXTContextANGLE(GLeglContext ctx,
+                                                             GLsizei length,
+                                                             const GLchar *marker);
+ANGLE_EXPORT void GL_APIENTRY PushMatrixContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY QueryCounterEXTContextANGLE(GLeglContext ctx,
+                                                          GLuint id,
+                                                          GLenum target);
+ANGLE_EXPORT GLbitfield GL_APIENTRY QueryMatrixxOESContextANGLE(GLeglContext ctx,
+                                                                GLfixed *mantissa,
+                                                                GLint *exponent);
+ANGLE_EXPORT void GL_APIENTRY ReadBufferContextANGLE(GLeglContext ctx, GLenum src);
+ANGLE_EXPORT void GL_APIENTRY ReadPixelsContextANGLE(GLeglContext ctx,
+                                                     GLint x,
+                                                     GLint y,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLenum format,
+                                                     GLenum type,
+                                                     void *pixels);
+ANGLE_EXPORT void GL_APIENTRY ReadnPixelsEXTContextANGLE(GLeglContext ctx,
+                                                         GLint x,
+                                                         GLint y,
+                                                         GLsizei width,
+                                                         GLsizei height,
+                                                         GLenum format,
+                                                         GLenum type,
+                                                         GLsizei bufSize,
+                                                         void *data);
+ANGLE_EXPORT void GL_APIENTRY ReleaseShaderCompilerContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageMultisampleContextANGLE(GLeglContext ctx,
+                                                                         GLenum target,
+                                                                         GLsizei samples,
+                                                                         GLenum internalformat,
+                                                                         GLsizei width,
+                                                                         GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageMultisampleANGLEContextANGLE(GLeglContext ctx,
+                                                                              GLenum target,
+                                                                              GLsizei samples,
+                                                                              GLenum internalformat,
+                                                                              GLsizei width,
+                                                                              GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageOESContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLenum internalformat,
+                                                                 GLsizei width,
+                                                                 GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY ResumeTransformFeedbackContextANGLE(GLeglContext ctx);
+ANGLE_EXPORT void GL_APIENTRY
+RotatefContextANGLE(GLeglContext ctx, GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+ANGLE_EXPORT void GL_APIENTRY
+RotatexContextANGLE(GLeglContext ctx, GLfixed angle, GLfixed x, GLfixed y, GLfixed z);
+ANGLE_EXPORT void GL_APIENTRY SampleCoverageContextANGLE(GLeglContext ctx,
+                                                         GLfloat value,
+                                                         GLboolean invert);
+ANGLE_EXPORT void GL_APIENTRY SampleCoveragexContextANGLE(GLeglContext ctx,
+                                                          GLclampx value,
+                                                          GLboolean invert);
+ANGLE_EXPORT void GL_APIENTRY SampleMaskiContextANGLE(GLeglContext ctx,
+                                                      GLuint maskNumber,
+                                                      GLbitfield mask);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterIivOESContextANGLE(GLeglContext ctx,
+                                                                 GLuint sampler,
+                                                                 GLenum pname,
+                                                                 const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                                  GLuint sampler,
+                                                                  GLenum pname,
+                                                                  const GLuint *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterfContextANGLE(GLeglContext ctx,
+                                                            GLuint sampler,
+                                                            GLenum pname,
+                                                            GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterfvContextANGLE(GLeglContext ctx,
+                                                             GLuint sampler,
+                                                             GLenum pname,
+                                                             const GLfloat *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameteriContextANGLE(GLeglContext ctx,
+                                                            GLuint sampler,
+                                                            GLenum pname,
+                                                            GLint param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterivContextANGLE(GLeglContext ctx,
+                                                             GLuint sampler,
+                                                             GLenum pname,
+                                                             const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY ScalefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z);
+ANGLE_EXPORT void GL_APIENTRY ScalexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z);
+ANGLE_EXPORT void GL_APIENTRY
+ScissorContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY SemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
+                                                                     GLuint semaphore,
+                                                                     GLenum pname,
+                                                                     const GLuint64 *params);
+ANGLE_EXPORT void GL_APIENTRY SetFenceNVContextANGLE(GLeglContext ctx,
+                                                     GLuint fence,
+                                                     GLenum condition);
+ANGLE_EXPORT void GL_APIENTRY ShadeModelContextANGLE(GLeglContext ctx, GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY ShaderBinaryContextANGLE(GLeglContext ctx,
+                                                       GLsizei count,
+                                                       const GLuint *shaders,
+                                                       GLenum binaryformat,
+                                                       const void *binary,
+                                                       GLsizei length);
+ANGLE_EXPORT void GL_APIENTRY ShaderSourceContextANGLE(GLeglContext ctx,
+                                                       GLuint shader,
+                                                       GLsizei count,
+                                                       const GLchar *const *string,
+                                                       const GLint *length);
+ANGLE_EXPORT void GL_APIENTRY SignalSemaphoreEXTContextANGLE(GLeglContext ctx,
+                                                             GLuint semaphore,
+                                                             GLuint numBufferBarriers,
+                                                             const GLuint *buffers,
+                                                             GLuint numTextureBarriers,
+                                                             const GLuint *textures,
+                                                             const GLenum *dstLayouts);
+ANGLE_EXPORT void GL_APIENTRY StencilFuncContextANGLE(GLeglContext ctx,
+                                                      GLenum func,
+                                                      GLint ref,
+                                                      GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY
+StencilFuncSeparateContextANGLE(GLeglContext ctx, GLenum face, GLenum func, GLint ref, GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilMaskContextANGLE(GLeglContext ctx, GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilMaskSeparateContextANGLE(GLeglContext ctx,
+                                                              GLenum face,
+                                                              GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilOpContextANGLE(GLeglContext ctx,
+                                                    GLenum fail,
+                                                    GLenum zfail,
+                                                    GLenum zpass);
+ANGLE_EXPORT void GL_APIENTRY StencilOpSeparateContextANGLE(GLeglContext ctx,
+                                                            GLenum face,
+                                                            GLenum sfail,
+                                                            GLenum dpfail,
+                                                            GLenum dppass);
+ANGLE_EXPORT GLboolean GL_APIENTRY TestFenceNVContextANGLE(GLeglContext ctx, GLuint fence);
+ANGLE_EXPORT void GL_APIENTRY TexCoordPointerContextANGLE(GLeglContext ctx,
+                                                          GLint size,
+                                                          GLenum type,
+                                                          GLsizei stride,
+                                                          const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY TexEnvfContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLenum pname,
+                                                  GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY TexEnvfvContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum pname,
+                                                   const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY TexEnviContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLenum pname,
+                                                  GLint param);
+ANGLE_EXPORT void GL_APIENTRY TexEnvivContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum pname,
+                                                   const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexEnvxContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLenum pname,
+                                                  GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY TexEnvxvContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum pname,
+                                                   const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY TexGenfOESContextANGLE(GLeglContext ctx,
+                                                     GLenum coord,
+                                                     GLenum pname,
+                                                     GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY TexGenfvOESContextANGLE(GLeglContext ctx,
+                                                      GLenum coord,
+                                                      GLenum pname,
+                                                      const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY TexGeniOESContextANGLE(GLeglContext ctx,
+                                                     GLenum coord,
+                                                     GLenum pname,
+                                                     GLint param);
+ANGLE_EXPORT void GL_APIENTRY TexGenivOESContextANGLE(GLeglContext ctx,
+                                                      GLenum coord,
+                                                      GLenum pname,
+                                                      const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexGenxOESContextANGLE(GLeglContext ctx,
+                                                     GLenum coord,
+                                                     GLenum pname,
+                                                     GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY TexGenxvOESContextANGLE(GLeglContext ctx,
+                                                      GLenum coord,
+                                                      GLenum pname,
+                                                      const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY TexImage2DContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLint level,
+                                                     GLint internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLint border,
+                                                     GLenum format,
+                                                     GLenum type,
+                                                     const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexImage3DContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLint level,
+                                                     GLint internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLsizei depth,
+                                                     GLint border,
+                                                     GLenum format,
+                                                     GLenum type,
+                                                     const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexImage3DOESContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLint level,
+                                                        GLenum internalformat,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLsizei depth,
+                                                        GLint border,
+                                                        GLenum format,
+                                                        GLenum type,
+                                                        const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexParameterIivOESContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLenum pname,
+                                                             const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLenum pname,
+                                                              const GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterfContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY TexParameterfvContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameteriContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLint param);
+ANGLE_EXPORT void GL_APIENTRY TexParameterivContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterxContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLenum pname,
+                                                        GLfixed param);
+ANGLE_EXPORT void GL_APIENTRY TexParameterxvContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         const GLfixed *params);
+ANGLE_EXPORT void GL_APIENTRY TexStorage1DEXTContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLsizei levels,
+                                                          GLenum internalformat,
+                                                          GLsizei width);
+ANGLE_EXPORT void GL_APIENTRY TexStorage2DContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLsizei levels,
+                                                       GLenum internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY TexStorage2DEXTContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLsizei levels,
+                                                          GLenum internalformat,
+                                                          GLsizei width,
+                                                          GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY TexStorage2DMultisampleContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLsizei samples,
+                                                                  GLenum internalformat,
+                                                                  GLsizei width,
+                                                                  GLsizei height,
+                                                                  GLboolean fixedsamplelocations);
+ANGLE_EXPORT void GL_APIENTRY TexStorage3DContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLsizei levels,
+                                                       GLenum internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLsizei depth);
+ANGLE_EXPORT void GL_APIENTRY TexStorage3DEXTContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLsizei levels,
+                                                          GLenum internalformat,
+                                                          GLsizei width,
+                                                          GLsizei height,
+                                                          GLsizei depth);
+ANGLE_EXPORT void GL_APIENTRY
+TexStorage3DMultisampleOESContextANGLE(GLeglContext ctx,
+                                       GLenum target,
+                                       GLsizei samples,
+                                       GLenum internalformat,
+                                       GLsizei width,
+                                       GLsizei height,
+                                       GLsizei depth,
+                                       GLboolean fixedsamplelocations);
+ANGLE_EXPORT void GL_APIENTRY TexStorageMem2DEXTContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLsizei levels,
+                                                             GLenum internalFormat,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             GLuint memory,
+                                                             GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY
+TexStorageMem2DMultisampleEXTContextANGLE(GLeglContext ctx,
+                                          GLenum target,
+                                          GLsizei samples,
+                                          GLenum internalFormat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLboolean fixedSampleLocations,
+                                          GLuint memory,
+                                          GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY TexStorageMem3DEXTContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLsizei levels,
+                                                             GLenum internalFormat,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             GLsizei depth,
+                                                             GLuint memory,
+                                                             GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY
+TexStorageMem3DMultisampleEXTContextANGLE(GLeglContext ctx,
+                                          GLenum target,
+                                          GLsizei samples,
+                                          GLenum internalFormat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLsizei depth,
+                                          GLboolean fixedSampleLocations,
+                                          GLuint memory,
+                                          GLuint64 offset);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage2DContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLint level,
+                                                        GLint xoffset,
+                                                        GLint yoffset,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLenum format,
+                                                        GLenum type,
+                                                        const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage3DContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLint level,
+                                                        GLint xoffset,
+                                                        GLint yoffset,
+                                                        GLint zoffset,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLsizei depth,
+                                                        GLenum format,
+                                                        GLenum type,
+                                                        const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLint level,
+                                                           GLint xoffset,
+                                                           GLint yoffset,
+                                                           GLint zoffset,
+                                                           GLsizei width,
+                                                           GLsizei height,
+                                                           GLsizei depth,
+                                                           GLenum format,
+                                                           GLenum type,
+                                                           const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TransformFeedbackVaryingsContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLsizei count,
+                                                                    const GLchar *const *varyings,
+                                                                    GLenum bufferMode);
+ANGLE_EXPORT void GL_APIENTRY TranslatefContextANGLE(GLeglContext ctx,
+                                                     GLfloat x,
+                                                     GLfloat y,
+                                                     GLfloat z);
+ANGLE_EXPORT void GL_APIENTRY TranslatexContextANGLE(GLeglContext ctx,
+                                                     GLfixed x,
+                                                     GLfixed y,
+                                                     GLfixed z);
+ANGLE_EXPORT void GL_APIENTRY Uniform1fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0);
+ANGLE_EXPORT void GL_APIENTRY Uniform1fvContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform1iContextANGLE(GLeglContext ctx, GLint location, GLint v0);
+ANGLE_EXPORT void GL_APIENTRY Uniform1ivContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform1uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0);
+ANGLE_EXPORT void GL_APIENTRY Uniform1uivContextANGLE(GLeglContext ctx,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform2fContextANGLE(GLeglContext ctx,
+                                                    GLint location,
+                                                    GLfloat v0,
+                                                    GLfloat v1);
+ANGLE_EXPORT void GL_APIENTRY Uniform2fvContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform2iContextANGLE(GLeglContext ctx,
+                                                    GLint location,
+                                                    GLint v0,
+                                                    GLint v1);
+ANGLE_EXPORT void GL_APIENTRY Uniform2ivContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform2uiContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLuint v0,
+                                                     GLuint v1);
+ANGLE_EXPORT void GL_APIENTRY Uniform2uivContextANGLE(GLeglContext ctx,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY
+Uniform3fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ANGLE_EXPORT void GL_APIENTRY Uniform3fvContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY
+Uniform3iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2);
+ANGLE_EXPORT void GL_APIENTRY Uniform3ivContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY
+Uniform3uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2);
+ANGLE_EXPORT void GL_APIENTRY Uniform3uivContextANGLE(GLeglContext ctx,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform4fContextANGLE(GLeglContext ctx,
+                                                    GLint location,
+                                                    GLfloat v0,
+                                                    GLfloat v1,
+                                                    GLfloat v2,
+                                                    GLfloat v3);
+ANGLE_EXPORT void GL_APIENTRY Uniform4fvContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY
+Uniform4iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ANGLE_EXPORT void GL_APIENTRY Uniform4ivContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLsizei count,
+                                                     const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform4uiContextANGLE(GLeglContext ctx,
+                                                     GLint location,
+                                                     GLuint v0,
+                                                     GLuint v1,
+                                                     GLuint v2,
+                                                     GLuint v3);
+ANGLE_EXPORT void GL_APIENTRY Uniform4uivContextANGLE(GLeglContext ctx,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY UniformBlockBindingContextANGLE(GLeglContext ctx,
+                                                              GLuint program,
+                                                              GLuint uniformBlockIndex,
+                                                              GLuint uniformBlockBinding);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix2fvContextANGLE(GLeglContext ctx,
+                                                           GLint location,
+                                                           GLsizei count,
+                                                           GLboolean transpose,
+                                                           const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix2x3fvContextANGLE(GLeglContext ctx,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             GLboolean transpose,
+                                                             const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix2x4fvContextANGLE(GLeglContext ctx,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             GLboolean transpose,
+                                                             const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix3fvContextANGLE(GLeglContext ctx,
+                                                           GLint location,
+                                                           GLsizei count,
+                                                           GLboolean transpose,
+                                                           const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix3x2fvContextANGLE(GLeglContext ctx,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             GLboolean transpose,
+                                                             const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix3x4fvContextANGLE(GLeglContext ctx,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             GLboolean transpose,
+                                                             const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix4fvContextANGLE(GLeglContext ctx,
+                                                           GLint location,
+                                                           GLsizei count,
+                                                           GLboolean transpose,
+                                                           const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix4x2fvContextANGLE(GLeglContext ctx,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             GLboolean transpose,
+                                                             const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix4x3fvContextANGLE(GLeglContext ctx,
+                                                             GLint location,
+                                                             GLsizei count,
+                                                             GLboolean transpose,
+                                                             const GLfloat *value);
+ANGLE_EXPORT GLboolean GL_APIENTRY UnmapBufferContextANGLE(GLeglContext ctx, GLenum target);
+ANGLE_EXPORT GLboolean GL_APIENTRY UnmapBufferOESContextANGLE(GLeglContext ctx, GLenum target);
+ANGLE_EXPORT void GL_APIENTRY UseProgramContextANGLE(GLeglContext ctx, GLuint program);
+ANGLE_EXPORT void GL_APIENTRY UseProgramStagesContextANGLE(GLeglContext ctx,
+                                                           GLuint pipeline,
+                                                           GLbitfield stages,
+                                                           GLuint program);
+ANGLE_EXPORT void GL_APIENTRY ValidateProgramContextANGLE(GLeglContext ctx, GLuint program);
+ANGLE_EXPORT void GL_APIENTRY ValidateProgramPipelineContextANGLE(GLeglContext ctx,
+                                                                  GLuint pipeline);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib1fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib1fvContextANGLE(GLeglContext ctx,
+                                                          GLuint index,
+                                                          const GLfloat *v);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib2fContextANGLE(GLeglContext ctx,
+                                                         GLuint index,
+                                                         GLfloat x,
+                                                         GLfloat y);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib2fvContextANGLE(GLeglContext ctx,
+                                                          GLuint index,
+                                                          const GLfloat *v);
+ANGLE_EXPORT void GL_APIENTRY
+VertexAttrib3fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y, GLfloat z);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib3fvContextANGLE(GLeglContext ctx,
+                                                          GLuint index,
+                                                          const GLfloat *v);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib4fContextANGLE(GLeglContext ctx,
+                                                         GLuint index,
+                                                         GLfloat x,
+                                                         GLfloat y,
+                                                         GLfloat z,
+                                                         GLfloat w);
+ANGLE_EXPORT void GL_APIENTRY VertexAttrib4fvContextANGLE(GLeglContext ctx,
+                                                          GLuint index,
+                                                          const GLfloat *v);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribBindingContextANGLE(GLeglContext ctx,
+                                                              GLuint attribindex,
+                                                              GLuint bindingindex);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribDivisorContextANGLE(GLeglContext ctx,
+                                                              GLuint index,
+                                                              GLuint divisor);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribDivisorANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLuint index,
+                                                                   GLuint divisor);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribDivisorEXTContextANGLE(GLeglContext ctx,
+                                                                 GLuint index,
+                                                                 GLuint divisor);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribFormatContextANGLE(GLeglContext ctx,
+                                                             GLuint attribindex,
+                                                             GLint size,
+                                                             GLenum type,
+                                                             GLboolean normalized,
+                                                             GLuint relativeoffset);
+ANGLE_EXPORT void GL_APIENTRY
+VertexAttribI4iContextANGLE(GLeglContext ctx, GLuint index, GLint x, GLint y, GLint z, GLint w);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4ivContextANGLE(GLeglContext ctx,
+                                                           GLuint index,
+                                                           const GLint *v);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4uiContextANGLE(GLeglContext ctx,
+                                                           GLuint index,
+                                                           GLuint x,
+                                                           GLuint y,
+                                                           GLuint z,
+                                                           GLuint w);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4uivContextANGLE(GLeglContext ctx,
+                                                            GLuint index,
+                                                            const GLuint *v);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribIFormatContextANGLE(GLeglContext ctx,
+                                                              GLuint attribindex,
+                                                              GLint size,
+                                                              GLenum type,
+                                                              GLuint relativeoffset);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribIPointerContextANGLE(GLeglContext ctx,
+                                                               GLuint index,
+                                                               GLint size,
+                                                               GLenum type,
+                                                               GLsizei stride,
+                                                               const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribPointerContextANGLE(GLeglContext ctx,
+                                                              GLuint index,
+                                                              GLint size,
+                                                              GLenum type,
+                                                              GLboolean normalized,
+                                                              GLsizei stride,
+                                                              const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY VertexBindingDivisorContextANGLE(GLeglContext ctx,
+                                                               GLuint bindingindex,
+                                                               GLuint divisor);
+ANGLE_EXPORT void GL_APIENTRY VertexPointerContextANGLE(GLeglContext ctx,
+                                                        GLint size,
+                                                        GLenum type,
+                                                        GLsizei stride,
+                                                        const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY
+ViewportContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY WaitSemaphoreEXTContextANGLE(GLeglContext ctx,
+                                                           GLuint semaphore,
+                                                           GLuint numBufferBarriers,
+                                                           const GLuint *buffers,
+                                                           GLuint numTextureBarriers,
+                                                           const GLuint *textures,
+                                                           const GLenum *srcLayouts);
+ANGLE_EXPORT void GL_APIENTRY WaitSyncContextANGLE(GLeglContext ctx,
+                                                   GLsync sync,
+                                                   GLbitfield flags,
+                                                   GLuint64 timeout);
+ANGLE_EXPORT void GL_APIENTRY WeightPointerOESContextANGLE(GLeglContext ctx,
+                                                           GLint size,
+                                                           GLenum type,
+                                                           GLsizei stride,
+                                                           const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY BindUniformLocationCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                      GLuint program,
+                                                                      GLint location,
+                                                                      const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY CoverageModulationCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                     GLenum components);
+ANGLE_EXPORT void GL_APIENTRY MatrixLoadfCHROMIUMContextANGLE(GLeglContext ctx,
+                                                              GLenum matrixMode,
+                                                              const GLfloat *matrix);
+ANGLE_EXPORT void GL_APIENTRY MatrixLoadIdentityCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                     GLenum matrixMode);
+ANGLE_EXPORT GLuint GL_APIENTRY GenPathsCHROMIUMContextANGLE(GLeglContext ctx, GLsizei range);
+ANGLE_EXPORT void GL_APIENTRY DeletePathsCHROMIUMContextANGLE(GLeglContext ctx,
+                                                              GLuint first,
+                                                              GLsizei range);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsPathCHROMIUMContextANGLE(GLeglContext ctx, GLuint path);
+ANGLE_EXPORT void GL_APIENTRY PathCommandsCHROMIUMContextANGLE(GLeglContext ctx,
+                                                               GLuint path,
+                                                               GLsizei numCommands,
+                                                               const GLubyte *commands,
+                                                               GLsizei numCoords,
+                                                               GLenum coordType,
+                                                               const void *coords);
+ANGLE_EXPORT void GL_APIENTRY PathParameterfCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                 GLuint path,
+                                                                 GLenum pname,
+                                                                 GLfloat value);
+ANGLE_EXPORT void GL_APIENTRY PathParameteriCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                 GLuint path,
+                                                                 GLenum pname,
+                                                                 GLint value);
+ANGLE_EXPORT void GL_APIENTRY GetPathParameterfvCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                     GLuint path,
+                                                                     GLenum pname,
+                                                                     GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY GetPathParameterivCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                     GLuint path,
+                                                                     GLenum pname,
+                                                                     GLint *value);
+ANGLE_EXPORT void GL_APIENTRY PathStencilFuncCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                  GLenum func,
+                                                                  GLint ref,
+                                                                  GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilFillPathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                  GLuint path,
+                                                                  GLenum fillMode,
+                                                                  GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY StencilStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                    GLuint path,
+                                                                    GLint reference,
+                                                                    GLuint mask);
+ANGLE_EXPORT void GL_APIENTRY CoverFillPathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                GLuint path,
+                                                                GLenum coverMode);
+ANGLE_EXPORT void GL_APIENTRY CoverStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                  GLuint path,
+                                                                  GLenum coverMode);
+ANGLE_EXPORT void GL_APIENTRY StencilThenCoverFillPathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                           GLuint path,
+                                                                           GLenum fillMode,
+                                                                           GLuint mask,
+                                                                           GLenum coverMode);
+ANGLE_EXPORT void GL_APIENTRY StencilThenCoverStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                             GLuint path,
+                                                                             GLint reference,
+                                                                             GLuint mask,
+                                                                             GLenum coverMode);
+ANGLE_EXPORT void GL_APIENTRY
+CoverFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                           GLsizei numPath,
+                                           GLenum pathNameType,
+                                           const void *paths,
+                                           GLuint pathBase,
+                                           GLenum coverMode,
+                                           GLenum transformType,
+                                           const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY
+CoverStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                             GLsizei numPath,
+                                             GLenum pathNameType,
+                                             const void *paths,
+                                             GLuint pathBase,
+                                             GLenum coverMode,
+                                             GLenum transformType,
+                                             const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY
+StencilStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                               GLsizei numPath,
+                                               GLenum pathNameType,
+                                               const void *paths,
+                                               GLuint pathBase,
+                                               GLint reference,
+                                               GLuint mask,
+                                               GLenum transformType,
+                                               const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY
+StencilFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                             GLsizei numPaths,
+                                             GLenum pathNameType,
+                                             const void *paths,
+                                             GLuint pathBase,
+                                             GLenum fillMode,
+                                             GLuint mask,
+                                             GLenum transformType,
+                                             const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY
+StencilThenCoverFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                      GLsizei numPaths,
+                                                      GLenum pathNameType,
+                                                      const void *paths,
+                                                      GLuint pathBase,
+                                                      GLenum fillMode,
+                                                      GLuint mask,
+                                                      GLenum coverMode,
+                                                      GLenum transformType,
+                                                      const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY
+StencilThenCoverStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                        GLsizei numPaths,
+                                                        GLenum pathNameType,
+                                                        const void *paths,
+                                                        GLuint pathBase,
+                                                        GLint reference,
+                                                        GLuint mask,
+                                                        GLenum coverMode,
+                                                        GLenum transformType,
+                                                        const GLfloat *transformValues);
+ANGLE_EXPORT void GL_APIENTRY BindFragmentInputLocationCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                            GLuint programs,
+                                                                            GLint location,
+                                                                            const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramPathFragmentInputGenCHROMIUMContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLenum genMode,
+                                                GLint components,
+                                                const GLfloat *coeffs);
+ANGLE_EXPORT void GL_APIENTRY CopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                              GLuint sourceId,
+                                                              GLint sourceLevel,
+                                                              GLenum destTarget,
+                                                              GLuint destId,
+                                                              GLint destLevel,
+                                                              GLint internalFormat,
+                                                              GLenum destType,
+                                                              GLboolean unpackFlipY,
+                                                              GLboolean unpackPremultiplyAlpha,
+                                                              GLboolean unpackUnmultiplyAlpha);
+ANGLE_EXPORT void GL_APIENTRY CopySubTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                 GLuint sourceId,
+                                                                 GLint sourceLevel,
+                                                                 GLenum destTarget,
+                                                                 GLuint destId,
+                                                                 GLint destLevel,
+                                                                 GLint xoffset,
+                                                                 GLint yoffset,
+                                                                 GLint x,
+                                                                 GLint y,
+                                                                 GLint width,
+                                                                 GLint height,
+                                                                 GLboolean unpackFlipY,
+                                                                 GLboolean unpackPremultiplyAlpha,
+                                                                 GLboolean unpackUnmultiplyAlpha);
+ANGLE_EXPORT void GL_APIENTRY CompressedCopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                        GLuint sourceId,
+                                                                        GLuint destId);
+ANGLE_EXPORT void GL_APIENTRY RequestExtensionANGLEContextANGLE(GLeglContext ctx,
+                                                                const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetBooleanvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLboolean *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                          GLenum target,
+                                                                          GLenum pname,
+                                                                          GLsizei bufSize,
+                                                                          GLsizei *length,
+                                                                          GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetFloatvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY
+GetFramebufferAttachmentParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLenum attachment,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetIntegervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetProgramivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLenum pname,
+                                                                  GLsizei bufSize,
+                                                                  GLsizei *length,
+                                                                  GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetRenderbufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                                GLenum target,
+                                                                                GLenum pname,
+                                                                                GLsizei bufSize,
+                                                                                GLsizei *length,
+                                                                                GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetShaderivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLuint shader,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                       GLenum target,
+                                                                       GLenum pname,
+                                                                       GLsizei bufSize,
+                                                                       GLsizei *length,
+                                                                       GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                       GLenum target,
+                                                                       GLenum pname,
+                                                                       GLsizei bufSize,
+                                                                       GLsizei *length,
+                                                                       GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLint location,
+                                                                  GLsizei bufSize,
+                                                                  GLsizei *length,
+                                                                  GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLint location,
+                                                                  GLsizei bufSize,
+                                                                  GLsizei *length,
+                                                                  GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                       GLuint index,
+                                                                       GLenum pname,
+                                                                       GLsizei bufSize,
+                                                                       GLsizei *length,
+                                                                       GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                       GLuint index,
+                                                                       GLenum pname,
+                                                                       GLsizei bufSize,
+                                                                       GLsizei *length,
+                                                                       GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribPointervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                             GLuint index,
+                                                                             GLenum pname,
+                                                                             GLsizei bufSize,
+                                                                             GLsizei *length,
+                                                                             void **pointer);
+ANGLE_EXPORT void GL_APIENTRY ReadPixelsRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLint x,
+                                                                GLint y,
+                                                                GLsizei width,
+                                                                GLsizei height,
+                                                                GLenum format,
+                                                                GLenum type,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLsizei *columns,
+                                                                GLsizei *rows,
+                                                                void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLint level,
+                                                                GLint internalformat,
+                                                                GLsizei width,
+                                                                GLsizei height,
+                                                                GLint border,
+                                                                GLenum format,
+                                                                GLenum type,
+                                                                GLsizei bufSize,
+                                                                const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                    GLenum target,
+                                                                    GLenum pname,
+                                                                    GLsizei bufSize,
+                                                                    const GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                    GLenum target,
+                                                                    GLenum pname,
+                                                                    GLsizei bufSize,
+                                                                    const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLenum target,
+                                                                   GLint level,
+                                                                   GLint xoffset,
+                                                                   GLint yoffset,
+                                                                   GLsizei width,
+                                                                   GLsizei height,
+                                                                   GLenum format,
+                                                                   GLenum type,
+                                                                   GLsizei bufSize,
+                                                                   const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLint level,
+                                                                GLint internalformat,
+                                                                GLsizei width,
+                                                                GLsizei height,
+                                                                GLsizei depth,
+                                                                GLint border,
+                                                                GLenum format,
+                                                                GLenum type,
+                                                                GLsizei bufSize,
+                                                                const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLenum target,
+                                                                   GLint level,
+                                                                   GLint xoffset,
+                                                                   GLint yoffset,
+                                                                   GLint zoffset,
+                                                                   GLsizei width,
+                                                                   GLsizei height,
+                                                                   GLsizei depth,
+                                                                   GLenum format,
+                                                                   GLenum type,
+                                                                   GLsizei bufSize,
+                                                                   const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                          GLenum target,
+                                                                          GLint level,
+                                                                          GLenum internalformat,
+                                                                          GLsizei width,
+                                                                          GLsizei height,
+                                                                          GLint border,
+                                                                          GLsizei imageSize,
+                                                                          GLsizei dataSize,
+                                                                          const GLvoid *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                             GLenum target,
+                                                                             GLint level,
+                                                                             GLsizei xoffset,
+                                                                             GLsizei yoffset,
+                                                                             GLsizei width,
+                                                                             GLsizei height,
+                                                                             GLenum format,
+                                                                             GLsizei imageSize,
+                                                                             GLsizei dataSize,
+                                                                             const GLvoid *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                          GLenum target,
+                                                                          GLint level,
+                                                                          GLenum internalformat,
+                                                                          GLsizei width,
+                                                                          GLsizei height,
+                                                                          GLsizei depth,
+                                                                          GLint border,
+                                                                          GLsizei imageSize,
+                                                                          GLsizei dataSize,
+                                                                          const GLvoid *data);
+ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                             GLenum target,
+                                                                             GLint level,
+                                                                             GLint xoffset,
+                                                                             GLint yoffset,
+                                                                             GLint zoffset,
+                                                                             GLsizei width,
+                                                                             GLsizei height,
+                                                                             GLsizei depth,
+                                                                             GLenum format,
+                                                                             GLsizei imageSize,
+                                                                             GLsizei dataSize,
+                                                                             const GLvoid *data);
+ANGLE_EXPORT void GL_APIENTRY GetQueryivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLenum target,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                       GLuint id,
+                                                                       GLenum pname,
+                                                                       GLsizei bufSize,
+                                                                       GLsizei *length,
+                                                                       GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferPointervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                       GLenum target,
+                                                                       GLenum pname,
+                                                                       GLsizei bufSize,
+                                                                       GLsizei *length,
+                                                                       void **params);
+ANGLE_EXPORT void GL_APIENTRY GetIntegeri_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLenum target,
+                                                                   GLuint index,
+                                                                   GLsizei bufSize,
+                                                                   GLsizei *length,
+                                                                   GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetInternalformativRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                         GLenum target,
+                                                                         GLenum internalformat,
+                                                                         GLenum pname,
+                                                                         GLsizei bufSize,
+                                                                         GLsizei *length,
+                                                                         GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                        GLuint index,
+                                                                        GLenum pname,
+                                                                        GLsizei bufSize,
+                                                                        GLsizei *length,
+                                                                        GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                         GLuint index,
+                                                                         GLenum pname,
+                                                                         GLsizei bufSize,
+                                                                         GLsizei *length,
+                                                                         GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLuint program,
+                                                                   GLint location,
+                                                                   GLsizei bufSize,
+                                                                   GLsizei *length,
+                                                                   GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY
+GetActiveUniformBlockivRobustANGLEContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLuint uniformBlockIndex,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLenum pname,
+                                                                   GLsizei bufSize,
+                                                                   GLsizei *length,
+                                                                   GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64i_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                     GLenum target,
+                                                                     GLuint index,
+                                                                     GLsizei bufSize,
+                                                                     GLsizei *length,
+                                                                     GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameteri64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                            GLenum target,
+                                                                            GLenum pname,
+                                                                            GLsizei bufSize,
+                                                                            GLsizei *length,
+                                                                            GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                        GLuint sampler,
+                                                                        GLuint pname,
+                                                                        GLsizei bufSize,
+                                                                        const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                        GLuint sampler,
+                                                                        GLenum pname,
+                                                                        GLsizei bufSize,
+                                                                        const GLfloat *param);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                           GLuint sampler,
+                                                                           GLenum pname,
+                                                                           GLsizei bufSize,
+                                                                           GLsizei *length,
+                                                                           GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                           GLuint sampler,
+                                                                           GLenum pname,
+                                                                           GLsizei bufSize,
+                                                                           GLsizei *length,
+                                                                           GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetFramebufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                               GLuint sampler,
+                                                                               GLenum pname,
+                                                                               GLsizei bufSize,
+                                                                               GLsizei *length,
+                                                                               GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetProgramInterfaceivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                           GLuint program,
+                                                                           GLenum programInterface,
+                                                                           GLenum pname,
+                                                                           GLsizei bufSize,
+                                                                           GLsizei *length,
+                                                                           GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetBooleani_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLenum target,
+                                                                   GLuint index,
+                                                                   GLsizei bufSize,
+                                                                   GLsizei *length,
+                                                                   GLboolean *data);
+ANGLE_EXPORT void GL_APIENTRY GetMultisamplefvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                      GLenum pname,
+                                                                      GLuint index,
+                                                                      GLsizei bufSize,
+                                                                      GLsizei *length,
+                                                                      GLfloat *val);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                            GLenum target,
+                                                                            GLint level,
+                                                                            GLenum pname,
+                                                                            GLsizei bufSize,
+                                                                            GLsizei *length,
+                                                                            GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                            GLenum target,
+                                                                            GLint level,
+                                                                            GLenum pname,
+                                                                            GLsizei bufSize,
+                                                                            GLsizei *length,
+                                                                            GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetPointervRobustANGLERobustANGLEContextANGLE(GLeglContext ctx,
+                                                                            GLenum pname,
+                                                                            GLsizei bufSize,
+                                                                            GLsizei *length,
+                                                                            void **params);
+ANGLE_EXPORT void GL_APIENTRY ReadnPixelsRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLint x,
+                                                                 GLint y,
+                                                                 GLsizei width,
+                                                                 GLsizei height,
+                                                                 GLenum format,
+                                                                 GLenum type,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLsizei *columns,
+                                                                 GLsizei *rows,
+                                                                 void *data);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLuint program,
+                                                                   GLint location,
+                                                                   GLsizei bufSize,
+                                                                   GLsizei *length,
+                                                                   GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLuint program,
+                                                                   GLint location,
+                                                                   GLsizei bufSize,
+                                                                   GLsizei *length,
+                                                                   GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetnUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                    GLuint program,
+                                                                    GLint location,
+                                                                    GLsizei bufSize,
+                                                                    GLsizei *length,
+                                                                    GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                     GLenum target,
+                                                                     GLenum pname,
+                                                                     GLsizei bufSize,
+                                                                     const GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                      GLenum target,
+                                                                      GLenum pname,
+                                                                      GLsizei bufSize,
+                                                                      const GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                        GLenum target,
+                                                                        GLenum pname,
+                                                                        GLsizei bufSize,
+                                                                        GLsizei *length,
+                                                                        GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                         GLenum target,
+                                                                         GLenum pname,
+                                                                         GLsizei bufSize,
+                                                                         GLsizei *length,
+                                                                         GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                         GLuint sampler,
+                                                                         GLenum pname,
+                                                                         GLsizei bufSize,
+                                                                         const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                          GLuint sampler,
+                                                                          GLenum pname,
+                                                                          GLsizei bufSize,
+                                                                          const GLuint *param);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                            GLuint sampler,
+                                                                            GLenum pname,
+                                                                            GLsizei bufSize,
+                                                                            GLsizei *length,
+                                                                            GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                             GLuint sampler,
+                                                                             GLenum pname,
+                                                                             GLsizei bufSize,
+                                                                             GLsizei *length,
+                                                                             GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                      GLuint id,
+                                                                      GLenum pname,
+                                                                      GLsizei bufSize,
+                                                                      GLsizei *length,
+                                                                      GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjecti64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                        GLuint id,
+                                                                        GLenum pname,
+                                                                        GLsizei bufSize,
+                                                                        GLsizei *length,
+                                                                        GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectui64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                         GLuint id,
+                                                                         GLenum pname,
+                                                                         GLsizei bufSize,
+                                                                         GLsizei *length,
+                                                                         GLuint64 *params);
+ANGLE_EXPORT void GL_APIENTRY CopyTexture3DANGLEContextANGLE(GLeglContext ctx,
+                                                             GLuint sourceId,
+                                                             GLint sourceLevel,
+                                                             GLenum destTarget,
+                                                             GLuint destId,
+                                                             GLint destLevel,
+                                                             GLint internalFormat,
+                                                             GLenum destType,
+                                                             GLboolean unpackFlipY,
+                                                             GLboolean unpackPremultiplyAlpha,
+                                                             GLboolean unpackUnmultiplyAlpha);
+ANGLE_EXPORT void GL_APIENTRY CopySubTexture3DANGLEContextANGLE(GLeglContext ctx,
+                                                                GLuint sourceId,
+                                                                GLint sourceLevel,
+                                                                GLenum destTarget,
+                                                                GLuint destId,
+                                                                GLint destLevel,
+                                                                GLint xoffset,
+                                                                GLint yoffset,
+                                                                GLint zoffset,
+                                                                GLint x,
+                                                                GLint y,
+                                                                GLint z,
+                                                                GLint width,
+                                                                GLint height,
+                                                                GLint depth,
+                                                                GLboolean unpackFlipY,
+                                                                GLboolean unpackPremultiplyAlpha,
+                                                                GLboolean unpackUnmultiplyAlpha);
+ANGLE_EXPORT void GL_APIENTRY
+TexStorage2DMultisampleANGLEContextANGLE(GLeglContext ctx,
+                                         GLenum target,
+                                         GLsizei samples,
+                                         GLenum internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLboolean fixedsamplelocations);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterivANGLEContextANGLE(GLeglContext ctx,
+                                                                      GLenum target,
+                                                                      GLint level,
+                                                                      GLenum pname,
+                                                                      GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfvANGLEContextANGLE(GLeglContext ctx,
+                                                                      GLenum target,
+                                                                      GLint level,
+                                                                      GLenum pname,
+                                                                      GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY MultiDrawArraysANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum mode,
+                                                               const GLint *firsts,
+                                                               const GLsizei *counts,
+                                                               GLsizei drawcount);
+ANGLE_EXPORT void GL_APIENTRY
+MultiDrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
+                                          GLenum mode,
+                                          const GLint *firsts,
+                                          const GLsizei *counts,
+                                          const GLsizei *instanceCounts,
+                                          GLsizei drawcount);
+ANGLE_EXPORT void GL_APIENTRY MultiDrawElementsANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLenum mode,
+                                                                 const GLsizei *counts,
+                                                                 GLenum type,
+                                                                 const GLvoid *const *indices,
+                                                                 GLsizei drawcount);
+ANGLE_EXPORT void GL_APIENTRY
+MultiDrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
+                                            GLenum mode,
+                                            const GLsizei *counts,
+                                            GLenum type,
+                                            const GLvoid *const *indices,
+                                            const GLsizei *instanceCounts,
+                                            GLsizei drawcount);
+ANGLE_EXPORT void GL_APIENTRY GetMultisamplefvANGLEContextANGLE(GLeglContext ctx,
+                                                                GLenum pname,
+                                                                GLuint index,
+                                                                GLfloat *val);
+ANGLE_EXPORT void GL_APIENTRY SampleMaskiANGLEContextANGLE(GLeglContext ctx,
+                                                           GLuint maskNumber,
+                                                           GLbitfield mask);
+ANGLE_EXPORT void GL_APIENTRY ProvokingVertexANGLEContextANGLE(GLeglContext ctx, GLenum mode);
+ANGLE_EXPORT void GL_APIENTRY LoseContextCHROMIUMContextANGLE(GLeglContext ctx,
+                                                              GLenum current,
+                                                              GLenum other);
+ANGLE_EXPORT void GL_APIENTRY TexImage2DExternalANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLint level,
+                                                                  GLint internalformat,
+                                                                  GLsizei width,
+                                                                  GLsizei height,
+                                                                  GLint border,
+                                                                  GLenum format,
+                                                                  GLenum type);
+ANGLE_EXPORT void GL_APIENTRY InvalidateTextureANGLEContextANGLE(GLeglContext ctx, GLenum target);
+}  // namespace gl
+
+#endif  // LIBGLESV2_ENTRY_POINTS_GLES_EXT_AUTOGEN_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/global_state.cpp b/gfx/angle/checkout/src/libGLESv2/global_state.cpp
new file mode 100644
index 0000000000..f9830a0f80
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/global_state.cpp
@@ -0,0 +1,225 @@
+//
+// Copyright(c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// global_state.cpp : Implements functions for querying the thread-local GL and EGL state.
+
+#include "libGLESv2/global_state.h"
+
+#include "common/debug.h"
+#include "common/platform.h"
+#include "common/tls.h"
+
+namespace gl
+{
+// In single-threaded cases we can avoid a TLS lookup for the current Context.
+//
+// Let a global single-threaded context have 3 states: unset, set, and multi-threaded.
+// Initially it is unset. Then, on MakeCurrent:
+//
+//  * if the ST context is unset                      -> set the global context.
+//  * if the ST context is set and matches the TLS    -> set the global context.
+//  * if the ST context is set and does not match TLS -> set multi-threaded mode.
+//  * if in multi-threaded mode, unset and subsequently ignore the global context.
+//
+// Implementation-wise we can use a pointer and a boolean to represent the three modes.
+Context *gSingleThreadedContext = nullptr;
+bool gIsMultiThreadedContext    = false;
+}  // namespace gl
+
+namespace egl
+{
+namespace
+{
+static TLSIndex threadTLS = TLS_INVALID_INDEX;
+Debug *g_Debug            = nullptr;
+std::atomic<std::mutex *> g_Mutex;
+
+Thread *AllocateCurrentThread()
+{
+    ASSERT(threadTLS != TLS_INVALID_INDEX);
+    if (threadTLS == TLS_INVALID_INDEX)
+    {
+        return nullptr;
+    }
+
+    Thread *thread = new Thread();
+    if (!SetTLSValue(threadTLS, thread))
+    {
+        ERR() << "Could not set thread local storage.";
+        return nullptr;
+    }
+
+    return thread;
+}
+
+void AllocateDebug()
+{
+    // All EGL calls use a global lock, this is thread safe
+    if (g_Debug == nullptr)
+    {
+        g_Debug = new Debug();
+    }
+}
+
+void AllocateMutex()
+{
+    if (g_Mutex == nullptr)
+    {
+        std::unique_ptr<std::mutex> newMutex(new std::mutex());
+        std::mutex *expected = nullptr;
+        if (g_Mutex.compare_exchange_strong(expected, newMutex.get()))
+        {
+            newMutex.release();
+        }
+    }
+}
+
+}  // anonymous namespace
+
+std::mutex &GetGlobalMutex()
+{
+    AllocateMutex();
+    return *g_Mutex;
+}
+
+Thread *GetCurrentThread()
+{
+    // Create a TLS index if one has not been created for this DLL
+    if (threadTLS == TLS_INVALID_INDEX)
+    {
+        threadTLS = CreateTLSIndex();
+    }
+
+    Thread *current = static_cast<Thread *>(GetTLSValue(threadTLS));
+
+    // ANGLE issue 488: when the dll is loaded after thread initialization,
+    // thread local storage (current) might not exist yet.
+    return (current ? current : AllocateCurrentThread());
+}
+
+Debug *GetDebug()
+{
+    AllocateDebug();
+    return g_Debug;
+}
+
+void SetContextCurrent(Thread *thread, gl::Context *context)
+{
+    // See above comment on gGlobalContext.
+    // If the context is in multi-threaded mode, ignore the global context.
+    if (!gl::gIsMultiThreadedContext)
+    {
+        // If the global context is unset or matches the current TLS, set the global context.
+        if (gl::gSingleThreadedContext == nullptr ||
+            gl::gSingleThreadedContext == thread->getContext())
+        {
+            gl::gSingleThreadedContext = context;
+        }
+        else
+        {
+            // If the global context is set and does not match TLS, set multi-threaded mode.
+            gl::gSingleThreadedContext  = nullptr;
+            gl::gIsMultiThreadedContext = true;
+        }
+    }
+    thread->setCurrent(context);
+}
+}  // namespace egl
+
+#ifdef ANGLE_PLATFORM_WINDOWS
+namespace egl
+{
+
+namespace
+{
+
+bool DeallocateCurrentThread()
+{
+    Thread *thread = static_cast<Thread *>(GetTLSValue(threadTLS));
+    SafeDelete(thread);
+    return SetTLSValue(threadTLS, nullptr);
+}
+
+void DeallocateDebug()
+{
+    SafeDelete(g_Debug);
+}
+
+void DeallocateMutex()
+{
+    std::mutex *mutex = g_Mutex.exchange(nullptr);
+    {
+        // Wait for the mutex to become released by other threads before deleting.
+        std::lock_guard<std::mutex> lock(*mutex);
+    }
+    SafeDelete(mutex);
+}
+
+bool InitializeProcess()
+{
+    ASSERT(g_Debug == nullptr);
+    AllocateDebug();
+
+    AllocateMutex();
+
+    threadTLS = CreateTLSIndex();
+    if (threadTLS == TLS_INVALID_INDEX)
+    {
+        return false;
+    }
+
+    return AllocateCurrentThread() != nullptr;
+}
+
+bool TerminateProcess()
+{
+    DeallocateDebug();
+
+    DeallocateMutex();
+
+    if (!DeallocateCurrentThread())
+    {
+        return false;
+    }
+
+    if (threadTLS != TLS_INVALID_INDEX)
+    {
+        TLSIndex tlsCopy = threadTLS;
+        threadTLS        = TLS_INVALID_INDEX;
+
+        if (!DestroyTLSIndex(tlsCopy))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+}  // anonymous namespace
+
+}  // namespace egl
+
+extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD reason, LPVOID)
+{
+    switch (reason)
+    {
+        case DLL_PROCESS_ATTACH:
+            return static_cast<BOOL>(egl::InitializeProcess());
+
+        case DLL_THREAD_ATTACH:
+            return static_cast<BOOL>(egl::AllocateCurrentThread() != nullptr);
+
+        case DLL_THREAD_DETACH:
+            return static_cast<BOOL>(egl::DeallocateCurrentThread());
+
+        case DLL_PROCESS_DETACH:
+            return static_cast<BOOL>(egl::TerminateProcess());
+    }
+
+    return TRUE;
+}
+#endif  // ANGLE_PLATFORM_WINDOWS
diff --git a/gfx/angle/checkout/src/libGLESv2/global_state.h b/gfx/angle/checkout/src/libGLESv2/global_state.h
new file mode 100644
index 0000000000..8d55b91905
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/global_state.h
@@ -0,0 +1,61 @@
+//
+// Copyright(c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// global_state.h : Defines functions for querying the thread-local GL and EGL state.
+
+#ifndef LIBGLESV2_GLOBALSTATE_H_
+#define LIBGLESV2_GLOBALSTATE_H_
+
+#include "libANGLE/Context.h"
+#include "libANGLE/Debug.h"
+#include "libANGLE/Thread.h"
+#include "libANGLE/features.h"
+
+#include <mutex>
+
+namespace egl
+{
+class Debug;
+class Thread;
+
+std::mutex &GetGlobalMutex();
+Thread *GetCurrentThread();
+Debug *GetDebug();
+void SetContextCurrent(Thread *thread, gl::Context *context);
+}  // namespace egl
+
+#define ANGLE_SCOPED_GLOBAL_LOCK() \
+    std::lock_guard<std::mutex> globalMutexLock(egl::GetGlobalMutex())
+
+namespace gl
+{
+extern Context *gSingleThreadedContext;
+
+ANGLE_INLINE Context *GetGlobalContext()
+{
+    if (gSingleThreadedContext)
+    {
+        return gSingleThreadedContext;
+    }
+
+    egl::Thread *thread = egl::GetCurrentThread();
+    return thread->getContext();
+}
+
+ANGLE_INLINE Context *GetValidGlobalContext()
+{
+    if (gSingleThreadedContext && !gSingleThreadedContext->isContextLost())
+    {
+        return gSingleThreadedContext;
+    }
+
+    egl::Thread *thread = egl::GetCurrentThread();
+    return thread->getValidContext();
+}
+
+}  // namespace gl
+
+#endif  // LIBGLESV2_GLOBALSTATE_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/libGLESv2.rc b/gfx/angle/checkout/src/libGLESv2/libGLESv2.rc
new file mode 100644
index 0000000000..4c3d137304
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/libGLESv2.rc
@@ -0,0 +1,103 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include <windows.h>
+#include "../common/version.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h""\r\n"
+    "#include ""../common/version.h""\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION ANGLE_MAJOR_VERSION,ANGLE_MINOR_VERSION,ANGLE_REVISION,0
+ PRODUCTVERSION ANGLE_MAJOR_VERSION,ANGLE_MINOR_VERSION,ANGLE_REVISION,0
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "ANGLE libGLESv2 Dynamic Link Library"
+            VALUE "FileVersion", ANGLE_VERSION_STRING
+            VALUE "InternalName", "libGLESv2"
+            VALUE "LegalCopyright", "Copyright (C) 2015 Google Inc."
+            VALUE "OriginalFilename", "libGLESv2.dll"
+            VALUE "PrivateBuild", ANGLE_VERSION_STRING
+            VALUE "ProductName", "ANGLE libGLESv2 Dynamic Link Library"
+            VALUE "ProductVersion", ANGLE_VERSION_STRING
+            VALUE "Comments", "Build Date: " ANGLE_COMMIT_DATE
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
diff --git a/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.cpp
new file mode 100644
index 0000000000..d5a4ae3628
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.cpp
@@ -0,0 +1,9775 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// libGLESv2.cpp: Implements the exported OpenGL ES functions.
+
+#include "angle_gl.h"
+
+#include "libGLESv2/entry_points_gles_1_0_autogen.h"
+#include "libGLESv2/entry_points_gles_2_0_autogen.h"
+#include "libGLESv2/entry_points_gles_3_0_autogen.h"
+#include "libGLESv2/entry_points_gles_3_1_autogen.h"
+#include "libGLESv2/entry_points_gles_ext_autogen.h"
+
+#include "common/event_tracer.h"
+
+extern "C" {
+
+// OpenGL ES 2.0
+void GL_APIENTRY glActiveTexture(GLenum texture)
+{
+    return gl::ActiveTexture(texture);
+}
+
+void GL_APIENTRY glAttachShader(GLuint program, GLuint shader)
+{
+    return gl::AttachShader(program, shader);
+}
+
+void GL_APIENTRY glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
+{
+    return gl::BindAttribLocation(program, index, name);
+}
+
+void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer)
+{
+    return gl::BindBuffer(target, buffer);
+}
+
+void GL_APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer)
+{
+    return gl::BindFramebuffer(target, framebuffer);
+}
+
+void GL_APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer)
+{
+    return gl::BindRenderbuffer(target, renderbuffer);
+}
+
+void GL_APIENTRY glBindTexture(GLenum target, GLuint texture)
+{
+    return gl::BindTexture(target, texture);
+}
+
+void GL_APIENTRY glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    return gl::BlendColor(red, green, blue, alpha);
+}
+
+void GL_APIENTRY glBlendEquation(GLenum mode)
+{
+    return gl::BlendEquation(mode);
+}
+
+void GL_APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+{
+    return gl::BlendEquationSeparate(modeRGB, modeAlpha);
+}
+
+void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor)
+{
+    return gl::BlendFunc(sfactor, dfactor);
+}
+
+void GL_APIENTRY glBlendFuncSeparate(GLenum sfactorRGB,
+                                     GLenum dfactorRGB,
+                                     GLenum sfactorAlpha,
+                                     GLenum dfactorAlpha)
+{
+    return gl::BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+}
+
+void GL_APIENTRY glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
+{
+    return gl::BufferData(target, size, data, usage);
+}
+
+void GL_APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
+{
+    return gl::BufferSubData(target, offset, size, data);
+}
+
+GLenum GL_APIENTRY glCheckFramebufferStatus(GLenum target)
+{
+    return gl::CheckFramebufferStatus(target);
+}
+
+void GL_APIENTRY glClear(GLbitfield mask)
+{
+    return gl::Clear(mask);
+}
+
+void GL_APIENTRY glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    return gl::ClearColor(red, green, blue, alpha);
+}
+
+void GL_APIENTRY glClearDepthf(GLfloat d)
+{
+    return gl::ClearDepthf(d);
+}
+
+void GL_APIENTRY glClearStencil(GLint s)
+{
+    return gl::ClearStencil(s);
+}
+
+void GL_APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+{
+    return gl::ColorMask(red, green, blue, alpha);
+}
+
+void GL_APIENTRY glCompileShader(GLuint shader)
+{
+    return gl::CompileShader(shader);
+}
+
+void GL_APIENTRY glCompressedTexImage2D(GLenum target,
+                                        GLint level,
+                                        GLenum internalformat,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLint border,
+                                        GLsizei imageSize,
+                                        const void *data)
+{
+    return gl::CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize,
+                                    data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage2D(GLenum target,
+                                           GLint level,
+                                           GLint xoffset,
+                                           GLint yoffset,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLenum format,
+                                           GLsizei imageSize,
+                                           const void *data)
+{
+    return gl::CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
+                                       imageSize, data);
+}
+
+void GL_APIENTRY glCopyTexImage2D(GLenum target,
+                                  GLint level,
+                                  GLenum internalformat,
+                                  GLint x,
+                                  GLint y,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLint border)
+{
+    return gl::CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+}
+
+void GL_APIENTRY glCopyTexSubImage2D(GLenum target,
+                                     GLint level,
+                                     GLint xoffset,
+                                     GLint yoffset,
+                                     GLint x,
+                                     GLint y,
+                                     GLsizei width,
+                                     GLsizei height)
+{
+    return gl::CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+}
+
+GLuint GL_APIENTRY glCreateProgram()
+{
+    return gl::CreateProgram();
+}
+
+GLuint GL_APIENTRY glCreateShader(GLenum type)
+{
+    return gl::CreateShader(type);
+}
+
+void GL_APIENTRY glCullFace(GLenum mode)
+{
+    return gl::CullFace(mode);
+}
+
+void GL_APIENTRY glDeleteBuffers(GLsizei n, const GLuint *buffers)
+{
+    return gl::DeleteBuffers(n, buffers);
+}
+
+void GL_APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
+{
+    return gl::DeleteFramebuffers(n, framebuffers);
+}
+
+void GL_APIENTRY glDeleteProgram(GLuint program)
+{
+    return gl::DeleteProgram(program);
+}
+
+void GL_APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
+{
+    return gl::DeleteRenderbuffers(n, renderbuffers);
+}
+
+void GL_APIENTRY glDeleteShader(GLuint shader)
+{
+    return gl::DeleteShader(shader);
+}
+
+void GL_APIENTRY glDeleteTextures(GLsizei n, const GLuint *textures)
+{
+    return gl::DeleteTextures(n, textures);
+}
+
+void GL_APIENTRY glDepthFunc(GLenum func)
+{
+    return gl::DepthFunc(func);
+}
+
+void GL_APIENTRY glDepthMask(GLboolean flag)
+{
+    return gl::DepthMask(flag);
+}
+
+void GL_APIENTRY glDepthRangef(GLfloat n, GLfloat f)
+{
+    return gl::DepthRangef(n, f);
+}
+
+void GL_APIENTRY glDetachShader(GLuint program, GLuint shader)
+{
+    return gl::DetachShader(program, shader);
+}
+
+void GL_APIENTRY glDisable(GLenum cap)
+{
+    return gl::Disable(cap);
+}
+
+void GL_APIENTRY glDisableVertexAttribArray(GLuint index)
+{
+    return gl::DisableVertexAttribArray(index);
+}
+
+void GL_APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+    return gl::DrawArrays(mode, first, count);
+}
+
+void GL_APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
+{
+    return gl::DrawElements(mode, count, type, indices);
+}
+
+void GL_APIENTRY glEnable(GLenum cap)
+{
+    return gl::Enable(cap);
+}
+
+void GL_APIENTRY glEnableVertexAttribArray(GLuint index)
+{
+    return gl::EnableVertexAttribArray(index);
+}
+
+void GL_APIENTRY glFinish()
+{
+    return gl::Finish();
+}
+
+void GL_APIENTRY glFlush()
+{
+    return gl::Flush();
+}
+
+void GL_APIENTRY glFramebufferRenderbuffer(GLenum target,
+                                           GLenum attachment,
+                                           GLenum renderbuffertarget,
+                                           GLuint renderbuffer)
+{
+    return gl::FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+}
+
+void GL_APIENTRY glFramebufferTexture2D(GLenum target,
+                                        GLenum attachment,
+                                        GLenum textarget,
+                                        GLuint texture,
+                                        GLint level)
+{
+    return gl::FramebufferTexture2D(target, attachment, textarget, texture, level);
+}
+
+void GL_APIENTRY glFrontFace(GLenum mode)
+{
+    return gl::FrontFace(mode);
+}
+
+void GL_APIENTRY glGenBuffers(GLsizei n, GLuint *buffers)
+{
+    return gl::GenBuffers(n, buffers);
+}
+
+void GL_APIENTRY glGenFramebuffers(GLsizei n, GLuint *framebuffers)
+{
+    return gl::GenFramebuffers(n, framebuffers);
+}
+
+void GL_APIENTRY glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
+{
+    return gl::GenRenderbuffers(n, renderbuffers);
+}
+
+void GL_APIENTRY glGenTextures(GLsizei n, GLuint *textures)
+{
+    return gl::GenTextures(n, textures);
+}
+
+void GL_APIENTRY glGenerateMipmap(GLenum target)
+{
+    return gl::GenerateMipmap(target);
+}
+
+void GL_APIENTRY glGetActiveAttrib(GLuint program,
+                                   GLuint index,
+                                   GLsizei bufSize,
+                                   GLsizei *length,
+                                   GLint *size,
+                                   GLenum *type,
+                                   GLchar *name)
+{
+    return gl::GetActiveAttrib(program, index, bufSize, length, size, type, name);
+}
+
+void GL_APIENTRY glGetActiveUniform(GLuint program,
+                                    GLuint index,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLint *size,
+                                    GLenum *type,
+                                    GLchar *name)
+{
+    return gl::GetActiveUniform(program, index, bufSize, length, size, type, name);
+}
+
+void GL_APIENTRY glGetAttachedShaders(GLuint program,
+                                      GLsizei maxCount,
+                                      GLsizei *count,
+                                      GLuint *shaders)
+{
+    return gl::GetAttachedShaders(program, maxCount, count, shaders);
+}
+
+GLint GL_APIENTRY glGetAttribLocation(GLuint program, const GLchar *name)
+{
+    return gl::GetAttribLocation(program, name);
+}
+
+void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean *data)
+{
+    return gl::GetBooleanv(pname, data);
+}
+
+void GL_APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetBufferParameteriv(target, pname, params);
+}
+
+GLenum GL_APIENTRY glGetError()
+{
+    return gl::GetError();
+}
+
+void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat *data)
+{
+    return gl::GetFloatv(pname, data);
+}
+
+void GL_APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target,
+                                                       GLenum attachment,
+                                                       GLenum pname,
+                                                       GLint *params)
+{
+    return gl::GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+}
+
+void GL_APIENTRY glGetIntegerv(GLenum pname, GLint *data)
+{
+    return gl::GetIntegerv(pname, data);
+}
+
+void GL_APIENTRY glGetProgramInfoLog(GLuint program,
+                                     GLsizei bufSize,
+                                     GLsizei *length,
+                                     GLchar *infoLog)
+{
+    return gl::GetProgramInfoLog(program, bufSize, length, infoLog);
+}
+
+void GL_APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint *params)
+{
+    return gl::GetProgramiv(program, pname, params);
+}
+
+void GL_APIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetRenderbufferParameteriv(target, pname, params);
+}
+
+void GL_APIENTRY glGetShaderInfoLog(GLuint shader,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLchar *infoLog)
+{
+    return gl::GetShaderInfoLog(shader, bufSize, length, infoLog);
+}
+
+void GL_APIENTRY glGetShaderPrecisionFormat(GLenum shadertype,
+                                            GLenum precisiontype,
+                                            GLint *range,
+                                            GLint *precision)
+{
+    return gl::GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+}
+
+void GL_APIENTRY glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
+{
+    return gl::GetShaderSource(shader, bufSize, length, source);
+}
+
+void GL_APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
+{
+    return gl::GetShaderiv(shader, pname, params);
+}
+
+const GLubyte *GL_APIENTRY glGetString(GLenum name)
+{
+    return gl::GetString(name);
+}
+
+void GL_APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+{
+    return gl::GetTexParameterfv(target, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetTexParameteriv(target, pname, params);
+}
+
+GLint GL_APIENTRY glGetUniformLocation(GLuint program, const GLchar *name)
+{
+    return gl::GetUniformLocation(program, name);
+}
+
+void GL_APIENTRY glGetUniformfv(GLuint program, GLint location, GLfloat *params)
+{
+    return gl::GetUniformfv(program, location, params);
+}
+
+void GL_APIENTRY glGetUniformiv(GLuint program, GLint location, GLint *params)
+{
+    return gl::GetUniformiv(program, location, params);
+}
+
+void GL_APIENTRY glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
+{
+    return gl::GetVertexAttribPointerv(index, pname, pointer);
+}
+
+void GL_APIENTRY glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
+{
+    return gl::GetVertexAttribfv(index, pname, params);
+}
+
+void GL_APIENTRY glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
+{
+    return gl::GetVertexAttribiv(index, pname, params);
+}
+
+void GL_APIENTRY glHint(GLenum target, GLenum mode)
+{
+    return gl::Hint(target, mode);
+}
+
+GLboolean GL_APIENTRY glIsBuffer(GLuint buffer)
+{
+    return gl::IsBuffer(buffer);
+}
+
+GLboolean GL_APIENTRY glIsEnabled(GLenum cap)
+{
+    return gl::IsEnabled(cap);
+}
+
+GLboolean GL_APIENTRY glIsFramebuffer(GLuint framebuffer)
+{
+    return gl::IsFramebuffer(framebuffer);
+}
+
+GLboolean GL_APIENTRY glIsProgram(GLuint program)
+{
+    return gl::IsProgram(program);
+}
+
+GLboolean GL_APIENTRY glIsRenderbuffer(GLuint renderbuffer)
+{
+    return gl::IsRenderbuffer(renderbuffer);
+}
+
+GLboolean GL_APIENTRY glIsShader(GLuint shader)
+{
+    return gl::IsShader(shader);
+}
+
+GLboolean GL_APIENTRY glIsTexture(GLuint texture)
+{
+    return gl::IsTexture(texture);
+}
+
+void GL_APIENTRY glLineWidth(GLfloat width)
+{
+    return gl::LineWidth(width);
+}
+
+void GL_APIENTRY glLinkProgram(GLuint program)
+{
+    return gl::LinkProgram(program);
+}
+
+void GL_APIENTRY glPixelStorei(GLenum pname, GLint param)
+{
+    return gl::PixelStorei(pname, param);
+}
+
+void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units)
+{
+    return gl::PolygonOffset(factor, units);
+}
+
+void GL_APIENTRY glReadPixels(GLint x,
+                              GLint y,
+                              GLsizei width,
+                              GLsizei height,
+                              GLenum format,
+                              GLenum type,
+                              void *pixels)
+{
+    return gl::ReadPixels(x, y, width, height, format, type, pixels);
+}
+
+void GL_APIENTRY glReleaseShaderCompiler()
+{
+    return gl::ReleaseShaderCompiler();
+}
+
+void GL_APIENTRY glRenderbufferStorage(GLenum target,
+                                       GLenum internalformat,
+                                       GLsizei width,
+                                       GLsizei height)
+{
+    return gl::RenderbufferStorage(target, internalformat, width, height);
+}
+
+void GL_APIENTRY glSampleCoverage(GLfloat value, GLboolean invert)
+{
+    return gl::SampleCoverage(value, invert);
+}
+
+void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    return gl::Scissor(x, y, width, height);
+}
+
+void GL_APIENTRY glShaderBinary(GLsizei count,
+                                const GLuint *shaders,
+                                GLenum binaryformat,
+                                const void *binary,
+                                GLsizei length)
+{
+    return gl::ShaderBinary(count, shaders, binaryformat, binary, length);
+}
+
+void GL_APIENTRY glShaderSource(GLuint shader,
+                                GLsizei count,
+                                const GLchar *const *string,
+                                const GLint *length)
+{
+    return gl::ShaderSource(shader, count, string, length);
+}
+
+void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+    return gl::StencilFunc(func, ref, mask);
+}
+
+void GL_APIENTRY glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+{
+    return gl::StencilFuncSeparate(face, func, ref, mask);
+}
+
+void GL_APIENTRY glStencilMask(GLuint mask)
+{
+    return gl::StencilMask(mask);
+}
+
+void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask)
+{
+    return gl::StencilMaskSeparate(face, mask);
+}
+
+void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+{
+    return gl::StencilOp(fail, zfail, zpass);
+}
+
+void GL_APIENTRY glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
+{
+    return gl::StencilOpSeparate(face, sfail, dpfail, dppass);
+}
+
+void GL_APIENTRY glTexImage2D(GLenum target,
+                              GLint level,
+                              GLint internalformat,
+                              GLsizei width,
+                              GLsizei height,
+                              GLint border,
+                              GLenum format,
+                              GLenum type,
+                              const void *pixels)
+{
+    return gl::TexImage2D(target, level, internalformat, width, height, border, format, type,
+                          pixels);
+}
+
+void GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param)
+{
+    return gl::TexParameterf(target, pname, param);
+}
+
+void GL_APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+    return gl::TexParameterfv(target, pname, params);
+}
+
+void GL_APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param)
+{
+    return gl::TexParameteri(target, pname, param);
+}
+
+void GL_APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
+{
+    return gl::TexParameteriv(target, pname, params);
+}
+
+void GL_APIENTRY glTexSubImage2D(GLenum target,
+                                 GLint level,
+                                 GLint xoffset,
+                                 GLint yoffset,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void *pixels)
+{
+    return gl::TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+}
+
+void GL_APIENTRY glUniform1f(GLint location, GLfloat v0)
+{
+    return gl::Uniform1f(location, v0);
+}
+
+void GL_APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
+{
+    return gl::Uniform1fv(location, count, value);
+}
+
+void GL_APIENTRY glUniform1i(GLint location, GLint v0)
+{
+    return gl::Uniform1i(location, v0);
+}
+
+void GL_APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint *value)
+{
+    return gl::Uniform1iv(location, count, value);
+}
+
+void GL_APIENTRY glUniform2f(GLint location, GLfloat v0, GLfloat v1)
+{
+    return gl::Uniform2f(location, v0, v1);
+}
+
+void GL_APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
+{
+    return gl::Uniform2fv(location, count, value);
+}
+
+void GL_APIENTRY glUniform2i(GLint location, GLint v0, GLint v1)
+{
+    return gl::Uniform2i(location, v0, v1);
+}
+
+void GL_APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint *value)
+{
+    return gl::Uniform2iv(location, count, value);
+}
+
+void GL_APIENTRY glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+{
+    return gl::Uniform3f(location, v0, v1, v2);
+}
+
+void GL_APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
+{
+    return gl::Uniform3fv(location, count, value);
+}
+
+void GL_APIENTRY glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
+{
+    return gl::Uniform3i(location, v0, v1, v2);
+}
+
+void GL_APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint *value)
+{
+    return gl::Uniform3iv(location, count, value);
+}
+
+void GL_APIENTRY glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+{
+    return gl::Uniform4f(location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
+{
+    return gl::Uniform4fv(location, count, value);
+}
+
+void GL_APIENTRY glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+{
+    return gl::Uniform4i(location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint *value)
+{
+    return gl::Uniform4iv(location, count, value);
+}
+
+void GL_APIENTRY glUniformMatrix2fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    return gl::UniformMatrix2fv(location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix3fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    return gl::UniformMatrix3fv(location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix4fv(GLint location,
+                                    GLsizei count,
+                                    GLboolean transpose,
+                                    const GLfloat *value)
+{
+    return gl::UniformMatrix4fv(location, count, transpose, value);
+}
+
+void GL_APIENTRY glUseProgram(GLuint program)
+{
+    return gl::UseProgram(program);
+}
+
+void GL_APIENTRY glValidateProgram(GLuint program)
+{
+    return gl::ValidateProgram(program);
+}
+
+void GL_APIENTRY glVertexAttrib1f(GLuint index, GLfloat x)
+{
+    return gl::VertexAttrib1f(index, x);
+}
+
+void GL_APIENTRY glVertexAttrib1fv(GLuint index, const GLfloat *v)
+{
+    return gl::VertexAttrib1fv(index, v);
+}
+
+void GL_APIENTRY glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
+{
+    return gl::VertexAttrib2f(index, x, y);
+}
+
+void GL_APIENTRY glVertexAttrib2fv(GLuint index, const GLfloat *v)
+{
+    return gl::VertexAttrib2fv(index, v);
+}
+
+void GL_APIENTRY glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+    return gl::VertexAttrib3f(index, x, y, z);
+}
+
+void GL_APIENTRY glVertexAttrib3fv(GLuint index, const GLfloat *v)
+{
+    return gl::VertexAttrib3fv(index, v);
+}
+
+void GL_APIENTRY glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+    return gl::VertexAttrib4f(index, x, y, z, w);
+}
+
+void GL_APIENTRY glVertexAttrib4fv(GLuint index, const GLfloat *v)
+{
+    return gl::VertexAttrib4fv(index, v);
+}
+
+void GL_APIENTRY glVertexAttribPointer(GLuint index,
+                                       GLint size,
+                                       GLenum type,
+                                       GLboolean normalized,
+                                       GLsizei stride,
+                                       const void *pointer)
+{
+    return gl::VertexAttribPointer(index, size, type, normalized, stride, pointer);
+}
+
+void GL_APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    return gl::Viewport(x, y, width, height);
+}
+
+// OpenGL ES 3.0
+void GL_APIENTRY glBeginQuery(GLenum target, GLuint id)
+{
+    return gl::BeginQuery(target, id);
+}
+
+void GL_APIENTRY glBeginTransformFeedback(GLenum primitiveMode)
+{
+    return gl::BeginTransformFeedback(primitiveMode);
+}
+
+void GL_APIENTRY glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
+{
+    return gl::BindBufferBase(target, index, buffer);
+}
+
+void GL_APIENTRY
+glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
+{
+    return gl::BindBufferRange(target, index, buffer, offset, size);
+}
+
+void GL_APIENTRY glBindSampler(GLuint unit, GLuint sampler)
+{
+    return gl::BindSampler(unit, sampler);
+}
+
+void GL_APIENTRY glBindTransformFeedback(GLenum target, GLuint id)
+{
+    return gl::BindTransformFeedback(target, id);
+}
+
+void GL_APIENTRY glBindVertexArray(GLuint array)
+{
+    return gl::BindVertexArray(array);
+}
+
+void GL_APIENTRY glBlitFramebuffer(GLint srcX0,
+                                   GLint srcY0,
+                                   GLint srcX1,
+                                   GLint srcY1,
+                                   GLint dstX0,
+                                   GLint dstY0,
+                                   GLint dstX1,
+                                   GLint dstY1,
+                                   GLbitfield mask,
+                                   GLenum filter)
+{
+    return gl::BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
+                               filter);
+}
+
+void GL_APIENTRY glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
+{
+    return gl::ClearBufferfi(buffer, drawbuffer, depth, stencil);
+}
+
+void GL_APIENTRY glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
+{
+    return gl::ClearBufferfv(buffer, drawbuffer, value);
+}
+
+void GL_APIENTRY glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
+{
+    return gl::ClearBufferiv(buffer, drawbuffer, value);
+}
+
+void GL_APIENTRY glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
+{
+    return gl::ClearBufferuiv(buffer, drawbuffer, value);
+}
+
+GLenum GL_APIENTRY glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+{
+    return gl::ClientWaitSync(sync, flags, timeout);
+}
+
+void GL_APIENTRY glCompressedTexImage3D(GLenum target,
+                                        GLint level,
+                                        GLenum internalformat,
+                                        GLsizei width,
+                                        GLsizei height,
+                                        GLsizei depth,
+                                        GLint border,
+                                        GLsizei imageSize,
+                                        const void *data)
+{
+    return gl::CompressedTexImage3D(target, level, internalformat, width, height, depth, border,
+                                    imageSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage3D(GLenum target,
+                                           GLint level,
+                                           GLint xoffset,
+                                           GLint yoffset,
+                                           GLint zoffset,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth,
+                                           GLenum format,
+                                           GLsizei imageSize,
+                                           const void *data)
+{
+    return gl::CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
+                                       depth, format, imageSize, data);
+}
+
+void GL_APIENTRY glCopyBufferSubData(GLenum readTarget,
+                                     GLenum writeTarget,
+                                     GLintptr readOffset,
+                                     GLintptr writeOffset,
+                                     GLsizeiptr size)
+{
+    return gl::CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+}
+
+void GL_APIENTRY glCopyTexSubImage3D(GLenum target,
+                                     GLint level,
+                                     GLint xoffset,
+                                     GLint yoffset,
+                                     GLint zoffset,
+                                     GLint x,
+                                     GLint y,
+                                     GLsizei width,
+                                     GLsizei height)
+{
+    return gl::CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+}
+
+void GL_APIENTRY glDeleteQueries(GLsizei n, const GLuint *ids)
+{
+    return gl::DeleteQueries(n, ids);
+}
+
+void GL_APIENTRY glDeleteSamplers(GLsizei count, const GLuint *samplers)
+{
+    return gl::DeleteSamplers(count, samplers);
+}
+
+void GL_APIENTRY glDeleteSync(GLsync sync)
+{
+    return gl::DeleteSync(sync);
+}
+
+void GL_APIENTRY glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
+{
+    return gl::DeleteTransformFeedbacks(n, ids);
+}
+
+void GL_APIENTRY glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
+{
+    return gl::DeleteVertexArrays(n, arrays);
+}
+
+void GL_APIENTRY glDrawArraysInstanced(GLenum mode,
+                                       GLint first,
+                                       GLsizei count,
+                                       GLsizei instancecount)
+{
+    return gl::DrawArraysInstanced(mode, first, count, instancecount);
+}
+
+void GL_APIENTRY glDrawBuffers(GLsizei n, const GLenum *bufs)
+{
+    return gl::DrawBuffers(n, bufs);
+}
+
+void GL_APIENTRY glDrawElementsInstanced(GLenum mode,
+                                         GLsizei count,
+                                         GLenum type,
+                                         const void *indices,
+                                         GLsizei instancecount)
+{
+    return gl::DrawElementsInstanced(mode, count, type, indices, instancecount);
+}
+
+void GL_APIENTRY glDrawRangeElements(GLenum mode,
+                                     GLuint start,
+                                     GLuint end,
+                                     GLsizei count,
+                                     GLenum type,
+                                     const void *indices)
+{
+    return gl::DrawRangeElements(mode, start, end, count, type, indices);
+}
+
+void GL_APIENTRY glEndQuery(GLenum target)
+{
+    return gl::EndQuery(target);
+}
+
+void GL_APIENTRY glEndTransformFeedback()
+{
+    return gl::EndTransformFeedback();
+}
+
+GLsync GL_APIENTRY glFenceSync(GLenum condition, GLbitfield flags)
+{
+    return gl::FenceSync(condition, flags);
+}
+
+void GL_APIENTRY glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
+{
+    return gl::FlushMappedBufferRange(target, offset, length);
+}
+
+void GL_APIENTRY glFramebufferTextureLayer(GLenum target,
+                                           GLenum attachment,
+                                           GLuint texture,
+                                           GLint level,
+                                           GLint layer)
+{
+    return gl::FramebufferTextureLayer(target, attachment, texture, level, layer);
+}
+
+void GL_APIENTRY glGenQueries(GLsizei n, GLuint *ids)
+{
+    return gl::GenQueries(n, ids);
+}
+
+void GL_APIENTRY glGenSamplers(GLsizei count, GLuint *samplers)
+{
+    return gl::GenSamplers(count, samplers);
+}
+
+void GL_APIENTRY glGenTransformFeedbacks(GLsizei n, GLuint *ids)
+{
+    return gl::GenTransformFeedbacks(n, ids);
+}
+
+void GL_APIENTRY glGenVertexArrays(GLsizei n, GLuint *arrays)
+{
+    return gl::GenVertexArrays(n, arrays);
+}
+
+void GL_APIENTRY glGetActiveUniformBlockName(GLuint program,
+                                             GLuint uniformBlockIndex,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLchar *uniformBlockName)
+{
+    return gl::GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length,
+                                         uniformBlockName);
+}
+
+void GL_APIENTRY glGetActiveUniformBlockiv(GLuint program,
+                                           GLuint uniformBlockIndex,
+                                           GLenum pname,
+                                           GLint *params)
+{
+    return gl::GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+}
+
+void GL_APIENTRY glGetActiveUniformsiv(GLuint program,
+                                       GLsizei uniformCount,
+                                       const GLuint *uniformIndices,
+                                       GLenum pname,
+                                       GLint *params)
+{
+    return gl::GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+}
+
+void GL_APIENTRY glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
+{
+    return gl::GetBufferParameteri64v(target, pname, params);
+}
+
+void GL_APIENTRY glGetBufferPointerv(GLenum target, GLenum pname, void **params)
+{
+    return gl::GetBufferPointerv(target, pname, params);
+}
+
+GLint GL_APIENTRY glGetFragDataLocation(GLuint program, const GLchar *name)
+{
+    return gl::GetFragDataLocation(program, name);
+}
+
+void GL_APIENTRY glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
+{
+    return gl::GetInteger64i_v(target, index, data);
+}
+
+void GL_APIENTRY glGetInteger64v(GLenum pname, GLint64 *data)
+{
+    return gl::GetInteger64v(pname, data);
+}
+
+void GL_APIENTRY glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
+{
+    return gl::GetIntegeri_v(target, index, data);
+}
+
+void GL_APIENTRY glGetInternalformativ(GLenum target,
+                                       GLenum internalformat,
+                                       GLenum pname,
+                                       GLsizei bufSize,
+                                       GLint *params)
+{
+    return gl::GetInternalformativ(target, internalformat, pname, bufSize, params);
+}
+
+void GL_APIENTRY glGetProgramBinary(GLuint program,
+                                    GLsizei bufSize,
+                                    GLsizei *length,
+                                    GLenum *binaryFormat,
+                                    void *binary)
+{
+    return gl::GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+}
+
+void GL_APIENTRY glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
+{
+    return gl::GetQueryObjectuiv(id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryiv(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetQueryiv(target, pname, params);
+}
+
+void GL_APIENTRY glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
+{
+    return gl::GetSamplerParameterfv(sampler, pname, params);
+}
+
+void GL_APIENTRY glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
+{
+    return gl::GetSamplerParameteriv(sampler, pname, params);
+}
+
+const GLubyte *GL_APIENTRY glGetStringi(GLenum name, GLuint index)
+{
+    return gl::GetStringi(name, index);
+}
+
+void GL_APIENTRY
+glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
+{
+    return gl::GetSynciv(sync, pname, bufSize, length, values);
+}
+
+void GL_APIENTRY glGetTransformFeedbackVarying(GLuint program,
+                                               GLuint index,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLsizei *size,
+                                               GLenum *type,
+                                               GLchar *name)
+{
+    return gl::GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+}
+
+GLuint GL_APIENTRY glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
+{
+    return gl::GetUniformBlockIndex(program, uniformBlockName);
+}
+
+void GL_APIENTRY glGetUniformIndices(GLuint program,
+                                     GLsizei uniformCount,
+                                     const GLchar *const *uniformNames,
+                                     GLuint *uniformIndices)
+{
+    return gl::GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+}
+
+void GL_APIENTRY glGetUniformuiv(GLuint program, GLint location, GLuint *params)
+{
+    return gl::GetUniformuiv(program, location, params);
+}
+
+void GL_APIENTRY glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
+{
+    return gl::GetVertexAttribIiv(index, pname, params);
+}
+
+void GL_APIENTRY glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
+{
+    return gl::GetVertexAttribIuiv(index, pname, params);
+}
+
+void GL_APIENTRY glInvalidateFramebuffer(GLenum target,
+                                         GLsizei numAttachments,
+                                         const GLenum *attachments)
+{
+    return gl::InvalidateFramebuffer(target, numAttachments, attachments);
+}
+
+void GL_APIENTRY glInvalidateSubFramebuffer(GLenum target,
+                                            GLsizei numAttachments,
+                                            const GLenum *attachments,
+                                            GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height)
+{
+    return gl::InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
+}
+
+GLboolean GL_APIENTRY glIsQuery(GLuint id)
+{
+    return gl::IsQuery(id);
+}
+
+GLboolean GL_APIENTRY glIsSampler(GLuint sampler)
+{
+    return gl::IsSampler(sampler);
+}
+
+GLboolean GL_APIENTRY glIsSync(GLsync sync)
+{
+    return gl::IsSync(sync);
+}
+
+GLboolean GL_APIENTRY glIsTransformFeedback(GLuint id)
+{
+    return gl::IsTransformFeedback(id);
+}
+
+GLboolean GL_APIENTRY glIsVertexArray(GLuint array)
+{
+    return gl::IsVertexArray(array);
+}
+
+void *GL_APIENTRY glMapBufferRange(GLenum target,
+                                   GLintptr offset,
+                                   GLsizeiptr length,
+                                   GLbitfield access)
+{
+    return gl::MapBufferRange(target, offset, length, access);
+}
+
+void GL_APIENTRY glPauseTransformFeedback()
+{
+    return gl::PauseTransformFeedback();
+}
+
+void GL_APIENTRY glProgramBinary(GLuint program,
+                                 GLenum binaryFormat,
+                                 const void *binary,
+                                 GLsizei length)
+{
+    return gl::ProgramBinary(program, binaryFormat, binary, length);
+}
+
+void GL_APIENTRY glProgramParameteri(GLuint program, GLenum pname, GLint value)
+{
+    return gl::ProgramParameteri(program, pname, value);
+}
+
+void GL_APIENTRY glReadBuffer(GLenum src)
+{
+    return gl::ReadBuffer(src);
+}
+
+void GL_APIENTRY glRenderbufferStorageMultisample(GLenum target,
+                                                  GLsizei samples,
+                                                  GLenum internalformat,
+                                                  GLsizei width,
+                                                  GLsizei height)
+{
+    return gl::RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+}
+
+void GL_APIENTRY glResumeTransformFeedback()
+{
+    return gl::ResumeTransformFeedback();
+}
+
+void GL_APIENTRY glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
+{
+    return gl::SamplerParameterf(sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
+{
+    return gl::SamplerParameterfv(sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
+{
+    return gl::SamplerParameteri(sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
+{
+    return gl::SamplerParameteriv(sampler, pname, param);
+}
+
+void GL_APIENTRY glTexImage3D(GLenum target,
+                              GLint level,
+                              GLint internalformat,
+                              GLsizei width,
+                              GLsizei height,
+                              GLsizei depth,
+                              GLint border,
+                              GLenum format,
+                              GLenum type,
+                              const void *pixels)
+{
+    return gl::TexImage3D(target, level, internalformat, width, height, depth, border, format, type,
+                          pixels);
+}
+
+void GL_APIENTRY
+glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
+{
+    return gl::TexStorage2D(target, levels, internalformat, width, height);
+}
+
+void GL_APIENTRY glTexStorage3D(GLenum target,
+                                GLsizei levels,
+                                GLenum internalformat,
+                                GLsizei width,
+                                GLsizei height,
+                                GLsizei depth)
+{
+    return gl::TexStorage3D(target, levels, internalformat, width, height, depth);
+}
+
+void GL_APIENTRY glTexSubImage3D(GLenum target,
+                                 GLint level,
+                                 GLint xoffset,
+                                 GLint yoffset,
+                                 GLint zoffset,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLsizei depth,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void *pixels)
+{
+    return gl::TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format,
+                             type, pixels);
+}
+
+void GL_APIENTRY glTransformFeedbackVaryings(GLuint program,
+                                             GLsizei count,
+                                             const GLchar *const *varyings,
+                                             GLenum bufferMode)
+{
+    return gl::TransformFeedbackVaryings(program, count, varyings, bufferMode);
+}
+
+void GL_APIENTRY glUniform1ui(GLint location, GLuint v0)
+{
+    return gl::Uniform1ui(location, v0);
+}
+
+void GL_APIENTRY glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
+{
+    return gl::Uniform1uiv(location, count, value);
+}
+
+void GL_APIENTRY glUniform2ui(GLint location, GLuint v0, GLuint v1)
+{
+    return gl::Uniform2ui(location, v0, v1);
+}
+
+void GL_APIENTRY glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
+{
+    return gl::Uniform2uiv(location, count, value);
+}
+
+void GL_APIENTRY glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
+{
+    return gl::Uniform3ui(location, v0, v1, v2);
+}
+
+void GL_APIENTRY glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
+{
+    return gl::Uniform3uiv(location, count, value);
+}
+
+void GL_APIENTRY glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+{
+    return gl::Uniform4ui(location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
+{
+    return gl::Uniform4uiv(location, count, value);
+}
+
+void GL_APIENTRY glUniformBlockBinding(GLuint program,
+                                       GLuint uniformBlockIndex,
+                                       GLuint uniformBlockBinding)
+{
+    return gl::UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+}
+
+void GL_APIENTRY glUniformMatrix2x3fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    return gl::UniformMatrix2x3fv(location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix2x4fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    return gl::UniformMatrix2x4fv(location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix3x2fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    return gl::UniformMatrix3x2fv(location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix3x4fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    return gl::UniformMatrix3x4fv(location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix4x2fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    return gl::UniformMatrix4x2fv(location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix4x3fv(GLint location,
+                                      GLsizei count,
+                                      GLboolean transpose,
+                                      const GLfloat *value)
+{
+    return gl::UniformMatrix4x3fv(location, count, transpose, value);
+}
+
+GLboolean GL_APIENTRY glUnmapBuffer(GLenum target)
+{
+    return gl::UnmapBuffer(target);
+}
+
+void GL_APIENTRY glVertexAttribDivisor(GLuint index, GLuint divisor)
+{
+    return gl::VertexAttribDivisor(index, divisor);
+}
+
+void GL_APIENTRY glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
+{
+    return gl::VertexAttribI4i(index, x, y, z, w);
+}
+
+void GL_APIENTRY glVertexAttribI4iv(GLuint index, const GLint *v)
+{
+    return gl::VertexAttribI4iv(index, v);
+}
+
+void GL_APIENTRY glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+{
+    return gl::VertexAttribI4ui(index, x, y, z, w);
+}
+
+void GL_APIENTRY glVertexAttribI4uiv(GLuint index, const GLuint *v)
+{
+    return gl::VertexAttribI4uiv(index, v);
+}
+
+void GL_APIENTRY
+glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    return gl::VertexAttribIPointer(index, size, type, stride, pointer);
+}
+
+void GL_APIENTRY glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+{
+    return gl::WaitSync(sync, flags, timeout);
+}
+
+// OpenGL ES 3.1
+void GL_APIENTRY glActiveShaderProgram(GLuint pipeline, GLuint program)
+{
+    return gl::ActiveShaderProgram(pipeline, program);
+}
+
+void GL_APIENTRY glBindImageTexture(GLuint unit,
+                                    GLuint texture,
+                                    GLint level,
+                                    GLboolean layered,
+                                    GLint layer,
+                                    GLenum access,
+                                    GLenum format)
+{
+    return gl::BindImageTexture(unit, texture, level, layered, layer, access, format);
+}
+
+void GL_APIENTRY glBindProgramPipeline(GLuint pipeline)
+{
+    return gl::BindProgramPipeline(pipeline);
+}
+
+void GL_APIENTRY glBindVertexBuffer(GLuint bindingindex,
+                                    GLuint buffer,
+                                    GLintptr offset,
+                                    GLsizei stride)
+{
+    return gl::BindVertexBuffer(bindingindex, buffer, offset, stride);
+}
+
+GLuint GL_APIENTRY glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
+{
+    return gl::CreateShaderProgramv(type, count, strings);
+}
+
+void GL_APIENTRY glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
+{
+    return gl::DeleteProgramPipelines(n, pipelines);
+}
+
+void GL_APIENTRY glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
+{
+    return gl::DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+}
+
+void GL_APIENTRY glDispatchComputeIndirect(GLintptr indirect)
+{
+    return gl::DispatchComputeIndirect(indirect);
+}
+
+void GL_APIENTRY glDrawArraysIndirect(GLenum mode, const void *indirect)
+{
+    return gl::DrawArraysIndirect(mode, indirect);
+}
+
+void GL_APIENTRY glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
+{
+    return gl::DrawElementsIndirect(mode, type, indirect);
+}
+
+void GL_APIENTRY glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
+{
+    return gl::FramebufferParameteri(target, pname, param);
+}
+
+void GL_APIENTRY glGenProgramPipelines(GLsizei n, GLuint *pipelines)
+{
+    return gl::GenProgramPipelines(n, pipelines);
+}
+
+void GL_APIENTRY glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
+{
+    return gl::GetBooleani_v(target, index, data);
+}
+
+void GL_APIENTRY glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetFramebufferParameteriv(target, pname, params);
+}
+
+void GL_APIENTRY glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
+{
+    return gl::GetMultisamplefv(pname, index, val);
+}
+
+void GL_APIENTRY glGetProgramInterfaceiv(GLuint program,
+                                         GLenum programInterface,
+                                         GLenum pname,
+                                         GLint *params)
+{
+    return gl::GetProgramInterfaceiv(program, programInterface, pname, params);
+}
+
+void GL_APIENTRY glGetProgramPipelineInfoLog(GLuint pipeline,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLchar *infoLog)
+{
+    return gl::GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+}
+
+void GL_APIENTRY glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
+{
+    return gl::GetProgramPipelineiv(pipeline, pname, params);
+}
+
+GLuint GL_APIENTRY glGetProgramResourceIndex(GLuint program,
+                                             GLenum programInterface,
+                                             const GLchar *name)
+{
+    return gl::GetProgramResourceIndex(program, programInterface, name);
+}
+
+GLint GL_APIENTRY glGetProgramResourceLocation(GLuint program,
+                                               GLenum programInterface,
+                                               const GLchar *name)
+{
+    return gl::GetProgramResourceLocation(program, programInterface, name);
+}
+
+void GL_APIENTRY glGetProgramResourceName(GLuint program,
+                                          GLenum programInterface,
+                                          GLuint index,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLchar *name)
+{
+    return gl::GetProgramResourceName(program, programInterface, index, bufSize, length, name);
+}
+
+void GL_APIENTRY glGetProgramResourceiv(GLuint program,
+                                        GLenum programInterface,
+                                        GLuint index,
+                                        GLsizei propCount,
+                                        const GLenum *props,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLint *params)
+{
+    return gl::GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize,
+                                    length, params);
+}
+
+void GL_APIENTRY glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
+{
+    return gl::GetTexLevelParameterfv(target, level, pname, params);
+}
+
+void GL_APIENTRY glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+{
+    return gl::GetTexLevelParameteriv(target, level, pname, params);
+}
+
+GLboolean GL_APIENTRY glIsProgramPipeline(GLuint pipeline)
+{
+    return gl::IsProgramPipeline(pipeline);
+}
+
+void GL_APIENTRY glMemoryBarrier(GLbitfield barriers)
+{
+    return gl::MemoryBarrier(barriers);
+}
+
+void GL_APIENTRY glMemoryBarrierByRegion(GLbitfield barriers)
+{
+    return gl::MemoryBarrierByRegion(barriers);
+}
+
+void GL_APIENTRY glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
+{
+    return gl::ProgramUniform1f(program, location, v0);
+}
+
+void GL_APIENTRY glProgramUniform1fv(GLuint program,
+                                     GLint location,
+                                     GLsizei count,
+                                     const GLfloat *value)
+{
+    return gl::ProgramUniform1fv(program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform1i(GLuint program, GLint location, GLint v0)
+{
+    return gl::ProgramUniform1i(program, location, v0);
+}
+
+void GL_APIENTRY glProgramUniform1iv(GLuint program,
+                                     GLint location,
+                                     GLsizei count,
+                                     const GLint *value)
+{
+    return gl::ProgramUniform1iv(program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
+{
+    return gl::ProgramUniform1ui(program, location, v0);
+}
+
+void GL_APIENTRY glProgramUniform1uiv(GLuint program,
+                                      GLint location,
+                                      GLsizei count,
+                                      const GLuint *value)
+{
+    return gl::ProgramUniform1uiv(program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
+{
+    return gl::ProgramUniform2f(program, location, v0, v1);
+}
+
+void GL_APIENTRY glProgramUniform2fv(GLuint program,
+                                     GLint location,
+                                     GLsizei count,
+                                     const GLfloat *value)
+{
+    return gl::ProgramUniform2fv(program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
+{
+    return gl::ProgramUniform2i(program, location, v0, v1);
+}
+
+void GL_APIENTRY glProgramUniform2iv(GLuint program,
+                                     GLint location,
+                                     GLsizei count,
+                                     const GLint *value)
+{
+    return gl::ProgramUniform2iv(program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
+{
+    return gl::ProgramUniform2ui(program, location, v0, v1);
+}
+
+void GL_APIENTRY glProgramUniform2uiv(GLuint program,
+                                      GLint location,
+                                      GLsizei count,
+                                      const GLuint *value)
+{
+    return gl::ProgramUniform2uiv(program, location, count, value);
+}
+
+void GL_APIENTRY
+glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+{
+    return gl::ProgramUniform3f(program, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glProgramUniform3fv(GLuint program,
+                                     GLint location,
+                                     GLsizei count,
+                                     const GLfloat *value)
+{
+    return gl::ProgramUniform3fv(program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
+{
+    return gl::ProgramUniform3i(program, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glProgramUniform3iv(GLuint program,
+                                     GLint location,
+                                     GLsizei count,
+                                     const GLint *value)
+{
+    return gl::ProgramUniform3iv(program, location, count, value);
+}
+
+void GL_APIENTRY
+glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
+{
+    return gl::ProgramUniform3ui(program, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glProgramUniform3uiv(GLuint program,
+                                      GLint location,
+                                      GLsizei count,
+                                      const GLuint *value)
+{
+    return gl::ProgramUniform3uiv(program, location, count, value);
+}
+
+void GL_APIENTRY
+glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+{
+    return gl::ProgramUniform4f(program, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glProgramUniform4fv(GLuint program,
+                                     GLint location,
+                                     GLsizei count,
+                                     const GLfloat *value)
+{
+    return gl::ProgramUniform4fv(program, location, count, value);
+}
+
+void GL_APIENTRY
+glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+{
+    return gl::ProgramUniform4i(program, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glProgramUniform4iv(GLuint program,
+                                     GLint location,
+                                     GLsizei count,
+                                     const GLint *value)
+{
+    return gl::ProgramUniform4iv(program, location, count, value);
+}
+
+void GL_APIENTRY
+glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+{
+    return gl::ProgramUniform4ui(program, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glProgramUniform4uiv(GLuint program,
+                                      GLint location,
+                                      GLsizei count,
+                                      const GLuint *value)
+{
+    return gl::ProgramUniform4uiv(program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix2fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix2fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix2x3fv(GLuint program,
+                                             GLint location,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix2x4fv(GLuint program,
+                                             GLint location,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix3fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix3fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix3x2fv(GLuint program,
+                                             GLint location,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix3x4fv(GLuint program,
+                                             GLint location,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix4fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix4fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix4x2fv(GLuint program,
+                                             GLint location,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix4x3fv(GLuint program,
+                                             GLint location,
+                                             GLsizei count,
+                                             GLboolean transpose,
+                                             const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glSampleMaski(GLuint maskNumber, GLbitfield mask)
+{
+    return gl::SampleMaski(maskNumber, mask);
+}
+
+void GL_APIENTRY glTexStorage2DMultisample(GLenum target,
+                                           GLsizei samples,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLboolean fixedsamplelocations)
+{
+    return gl::TexStorage2DMultisample(target, samples, internalformat, width, height,
+                                       fixedsamplelocations);
+}
+
+void GL_APIENTRY glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
+{
+    return gl::UseProgramStages(pipeline, stages, program);
+}
+
+void GL_APIENTRY glValidateProgramPipeline(GLuint pipeline)
+{
+    return gl::ValidateProgramPipeline(pipeline);
+}
+
+void GL_APIENTRY glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
+{
+    return gl::VertexAttribBinding(attribindex, bindingindex);
+}
+
+void GL_APIENTRY glVertexAttribFormat(GLuint attribindex,
+                                      GLint size,
+                                      GLenum type,
+                                      GLboolean normalized,
+                                      GLuint relativeoffset)
+{
+    return gl::VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+}
+
+void GL_APIENTRY glVertexAttribIFormat(GLuint attribindex,
+                                       GLint size,
+                                       GLenum type,
+                                       GLuint relativeoffset)
+{
+    return gl::VertexAttribIFormat(attribindex, size, type, relativeoffset);
+}
+
+void GL_APIENTRY glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
+{
+    return gl::VertexBindingDivisor(bindingindex, divisor);
+}
+
+// OpenGL ES 1.0
+void GL_APIENTRY glAlphaFunc(GLenum func, GLfloat ref)
+{
+    return gl::AlphaFunc(func, ref);
+}
+
+void GL_APIENTRY glAlphaFuncx(GLenum func, GLfixed ref)
+{
+    return gl::AlphaFuncx(func, ref);
+}
+
+void GL_APIENTRY glClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+    return gl::ClearColorx(red, green, blue, alpha);
+}
+
+void GL_APIENTRY glClearDepthx(GLfixed depth)
+{
+    return gl::ClearDepthx(depth);
+}
+
+void GL_APIENTRY glClientActiveTexture(GLenum texture)
+{
+    return gl::ClientActiveTexture(texture);
+}
+
+void GL_APIENTRY glClipPlanef(GLenum p, const GLfloat *eqn)
+{
+    return gl::ClipPlanef(p, eqn);
+}
+
+void GL_APIENTRY glClipPlanex(GLenum plane, const GLfixed *equation)
+{
+    return gl::ClipPlanex(plane, equation);
+}
+
+void GL_APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    return gl::Color4f(red, green, blue, alpha);
+}
+
+void GL_APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+    return gl::Color4ub(red, green, blue, alpha);
+}
+
+void GL_APIENTRY glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+    return gl::Color4x(red, green, blue, alpha);
+}
+
+void GL_APIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    return gl::ColorPointer(size, type, stride, pointer);
+}
+
+void GL_APIENTRY glDepthRangex(GLfixed n, GLfixed f)
+{
+    return gl::DepthRangex(n, f);
+}
+
+void GL_APIENTRY glDisableClientState(GLenum array)
+{
+    return gl::DisableClientState(array);
+}
+
+void GL_APIENTRY glEnableClientState(GLenum array)
+{
+    return gl::EnableClientState(array);
+}
+
+void GL_APIENTRY glFogf(GLenum pname, GLfloat param)
+{
+    return gl::Fogf(pname, param);
+}
+
+void GL_APIENTRY glFogfv(GLenum pname, const GLfloat *params)
+{
+    return gl::Fogfv(pname, params);
+}
+
+void GL_APIENTRY glFogx(GLenum pname, GLfixed param)
+{
+    return gl::Fogx(pname, param);
+}
+
+void GL_APIENTRY glFogxv(GLenum pname, const GLfixed *param)
+{
+    return gl::Fogxv(pname, param);
+}
+
+void GL_APIENTRY glFrustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
+{
+    return gl::Frustumf(l, r, b, t, n, f);
+}
+
+void GL_APIENTRY glFrustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
+{
+    return gl::Frustumx(l, r, b, t, n, f);
+}
+
+void GL_APIENTRY glGetClipPlanef(GLenum plane, GLfloat *equation)
+{
+    return gl::GetClipPlanef(plane, equation);
+}
+
+void GL_APIENTRY glGetClipPlanex(GLenum plane, GLfixed *equation)
+{
+    return gl::GetClipPlanex(plane, equation);
+}
+
+void GL_APIENTRY glGetFixedv(GLenum pname, GLfixed *params)
+{
+    return gl::GetFixedv(pname, params);
+}
+
+void GL_APIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
+{
+    return gl::GetLightfv(light, pname, params);
+}
+
+void GL_APIENTRY glGetLightxv(GLenum light, GLenum pname, GLfixed *params)
+{
+    return gl::GetLightxv(light, pname, params);
+}
+
+void GL_APIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
+{
+    return gl::GetMaterialfv(face, pname, params);
+}
+
+void GL_APIENTRY glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params)
+{
+    return gl::GetMaterialxv(face, pname, params);
+}
+
+void GL_APIENTRY glGetPointerv(GLenum pname, void **params)
+{
+    return gl::GetPointerv(pname, params);
+}
+
+void GL_APIENTRY glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
+{
+    return gl::GetTexEnvfv(target, pname, params);
+}
+
+void GL_APIENTRY glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetTexEnviv(target, pname, params);
+}
+
+void GL_APIENTRY glGetTexEnvxv(GLenum target, GLenum pname, GLfixed *params)
+{
+    return gl::GetTexEnvxv(target, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
+{
+    return gl::GetTexParameterxv(target, pname, params);
+}
+
+void GL_APIENTRY glLightModelf(GLenum pname, GLfloat param)
+{
+    return gl::LightModelf(pname, param);
+}
+
+void GL_APIENTRY glLightModelfv(GLenum pname, const GLfloat *params)
+{
+    return gl::LightModelfv(pname, params);
+}
+
+void GL_APIENTRY glLightModelx(GLenum pname, GLfixed param)
+{
+    return gl::LightModelx(pname, param);
+}
+
+void GL_APIENTRY glLightModelxv(GLenum pname, const GLfixed *param)
+{
+    return gl::LightModelxv(pname, param);
+}
+
+void GL_APIENTRY glLightf(GLenum light, GLenum pname, GLfloat param)
+{
+    return gl::Lightf(light, pname, param);
+}
+
+void GL_APIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params)
+{
+    return gl::Lightfv(light, pname, params);
+}
+
+void GL_APIENTRY glLightx(GLenum light, GLenum pname, GLfixed param)
+{
+    return gl::Lightx(light, pname, param);
+}
+
+void GL_APIENTRY glLightxv(GLenum light, GLenum pname, const GLfixed *params)
+{
+    return gl::Lightxv(light, pname, params);
+}
+
+void GL_APIENTRY glLineWidthx(GLfixed width)
+{
+    return gl::LineWidthx(width);
+}
+
+void GL_APIENTRY glLoadIdentity()
+{
+    return gl::LoadIdentity();
+}
+
+void GL_APIENTRY glLoadMatrixf(const GLfloat *m)
+{
+    return gl::LoadMatrixf(m);
+}
+
+void GL_APIENTRY glLoadMatrixx(const GLfixed *m)
+{
+    return gl::LoadMatrixx(m);
+}
+
+void GL_APIENTRY glLogicOp(GLenum opcode)
+{
+    return gl::LogicOp(opcode);
+}
+
+void GL_APIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+    return gl::Materialf(face, pname, param);
+}
+
+void GL_APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
+{
+    return gl::Materialfv(face, pname, params);
+}
+
+void GL_APIENTRY glMaterialx(GLenum face, GLenum pname, GLfixed param)
+{
+    return gl::Materialx(face, pname, param);
+}
+
+void GL_APIENTRY glMaterialxv(GLenum face, GLenum pname, const GLfixed *param)
+{
+    return gl::Materialxv(face, pname, param);
+}
+
+void GL_APIENTRY glMatrixMode(GLenum mode)
+{
+    return gl::MatrixMode(mode);
+}
+
+void GL_APIENTRY glMultMatrixf(const GLfloat *m)
+{
+    return gl::MultMatrixf(m);
+}
+
+void GL_APIENTRY glMultMatrixx(const GLfixed *m)
+{
+    return gl::MultMatrixx(m);
+}
+
+void GL_APIENTRY glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+    return gl::MultiTexCoord4f(target, s, t, r, q);
+}
+
+void GL_APIENTRY glMultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
+{
+    return gl::MultiTexCoord4x(texture, s, t, r, q);
+}
+
+void GL_APIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+{
+    return gl::Normal3f(nx, ny, nz);
+}
+
+void GL_APIENTRY glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz)
+{
+    return gl::Normal3x(nx, ny, nz);
+}
+
+void GL_APIENTRY glNormalPointer(GLenum type, GLsizei stride, const void *pointer)
+{
+    return gl::NormalPointer(type, stride, pointer);
+}
+
+void GL_APIENTRY glOrthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
+{
+    return gl::Orthof(l, r, b, t, n, f);
+}
+
+void GL_APIENTRY glOrthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
+{
+    return gl::Orthox(l, r, b, t, n, f);
+}
+
+void GL_APIENTRY glPointParameterf(GLenum pname, GLfloat param)
+{
+    return gl::PointParameterf(pname, param);
+}
+
+void GL_APIENTRY glPointParameterfv(GLenum pname, const GLfloat *params)
+{
+    return gl::PointParameterfv(pname, params);
+}
+
+void GL_APIENTRY glPointParameterx(GLenum pname, GLfixed param)
+{
+    return gl::PointParameterx(pname, param);
+}
+
+void GL_APIENTRY glPointParameterxv(GLenum pname, const GLfixed *params)
+{
+    return gl::PointParameterxv(pname, params);
+}
+
+void GL_APIENTRY glPointSize(GLfloat size)
+{
+    return gl::PointSize(size);
+}
+
+void GL_APIENTRY glPointSizex(GLfixed size)
+{
+    return gl::PointSizex(size);
+}
+
+void GL_APIENTRY glPolygonOffsetx(GLfixed factor, GLfixed units)
+{
+    return gl::PolygonOffsetx(factor, units);
+}
+
+void GL_APIENTRY glPopMatrix()
+{
+    return gl::PopMatrix();
+}
+
+void GL_APIENTRY glPushMatrix()
+{
+    return gl::PushMatrix();
+}
+
+void GL_APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+    return gl::Rotatef(angle, x, y, z);
+}
+
+void GL_APIENTRY glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
+{
+    return gl::Rotatex(angle, x, y, z);
+}
+
+void GL_APIENTRY glSampleCoveragex(GLclampx value, GLboolean invert)
+{
+    return gl::SampleCoveragex(value, invert);
+}
+
+void GL_APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+    return gl::Scalef(x, y, z);
+}
+
+void GL_APIENTRY glScalex(GLfixed x, GLfixed y, GLfixed z)
+{
+    return gl::Scalex(x, y, z);
+}
+
+void GL_APIENTRY glShadeModel(GLenum mode)
+{
+    return gl::ShadeModel(mode);
+}
+
+void GL_APIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    return gl::TexCoordPointer(size, type, stride, pointer);
+}
+
+void GL_APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+    return gl::TexEnvf(target, pname, param);
+}
+
+void GL_APIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
+{
+    return gl::TexEnvfv(target, pname, params);
+}
+
+void GL_APIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+    return gl::TexEnvi(target, pname, param);
+}
+
+void GL_APIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *params)
+{
+    return gl::TexEnviv(target, pname, params);
+}
+
+void GL_APIENTRY glTexEnvx(GLenum target, GLenum pname, GLfixed param)
+{
+    return gl::TexEnvx(target, pname, param);
+}
+
+void GL_APIENTRY glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
+{
+    return gl::TexEnvxv(target, pname, params);
+}
+
+void GL_APIENTRY glTexParameterx(GLenum target, GLenum pname, GLfixed param)
+{
+    return gl::TexParameterx(target, pname, param);
+}
+
+void GL_APIENTRY glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
+{
+    return gl::TexParameterxv(target, pname, params);
+}
+
+void GL_APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+    return gl::Translatef(x, y, z);
+}
+
+void GL_APIENTRY glTranslatex(GLfixed x, GLfixed y, GLfixed z)
+{
+    return gl::Translatex(x, y, z);
+}
+
+void GL_APIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    return gl::VertexPointer(size, type, stride, pointer);
+}
+
+// GL_ANGLE_copy_texture_3d
+void GL_APIENTRY glCopyTexture3DANGLE(GLuint sourceId,
+                                      GLint sourceLevel,
+                                      GLenum destTarget,
+                                      GLuint destId,
+                                      GLint destLevel,
+                                      GLint internalFormat,
+                                      GLenum destType,
+                                      GLboolean unpackFlipY,
+                                      GLboolean unpackPremultiplyAlpha,
+                                      GLboolean unpackUnmultiplyAlpha)
+{
+    return gl::CopyTexture3DANGLE(sourceId, sourceLevel, destTarget, destId, destLevel,
+                                  internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                                  unpackUnmultiplyAlpha);
+}
+
+void GL_APIENTRY glCopySubTexture3DANGLE(GLuint sourceId,
+                                         GLint sourceLevel,
+                                         GLenum destTarget,
+                                         GLuint destId,
+                                         GLint destLevel,
+                                         GLint xoffset,
+                                         GLint yoffset,
+                                         GLint zoffset,
+                                         GLint x,
+                                         GLint y,
+                                         GLint z,
+                                         GLint width,
+                                         GLint height,
+                                         GLint depth,
+                                         GLboolean unpackFlipY,
+                                         GLboolean unpackPremultiplyAlpha,
+                                         GLboolean unpackUnmultiplyAlpha)
+{
+    return gl::CopySubTexture3DANGLE(sourceId, sourceLevel, destTarget, destId, destLevel, xoffset,
+                                     yoffset, zoffset, x, y, z, width, height, depth, unpackFlipY,
+                                     unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+// GL_ANGLE_framebuffer_blit
+void GL_APIENTRY glBlitFramebufferANGLE(GLint srcX0,
+                                        GLint srcY0,
+                                        GLint srcX1,
+                                        GLint srcY1,
+                                        GLint dstX0,
+                                        GLint dstY0,
+                                        GLint dstX1,
+                                        GLint dstY1,
+                                        GLbitfield mask,
+                                        GLenum filter)
+{
+    return gl::BlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
+                                    filter);
+}
+
+// GL_ANGLE_framebuffer_multisample
+void GL_APIENTRY glRenderbufferStorageMultisampleANGLE(GLenum target,
+                                                       GLsizei samples,
+                                                       GLenum internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height)
+{
+    return gl::RenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
+}
+
+// GL_ANGLE_instanced_arrays
+void GL_APIENTRY glDrawArraysInstancedANGLE(GLenum mode,
+                                            GLint first,
+                                            GLsizei count,
+                                            GLsizei primcount)
+{
+    return gl::DrawArraysInstancedANGLE(mode, first, count, primcount);
+}
+
+void GL_APIENTRY glDrawElementsInstancedANGLE(GLenum mode,
+                                              GLsizei count,
+                                              GLenum type,
+                                              const void *indices,
+                                              GLsizei primcount)
+{
+    return gl::DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
+}
+
+void GL_APIENTRY glVertexAttribDivisorANGLE(GLuint index, GLuint divisor)
+{
+    return gl::VertexAttribDivisorANGLE(index, divisor);
+}
+
+// GL_ANGLE_multi_draw
+void GL_APIENTRY glMultiDrawArraysANGLE(GLenum mode,
+                                        const GLint *firsts,
+                                        const GLsizei *counts,
+                                        GLsizei drawcount)
+{
+    return gl::MultiDrawArraysANGLE(mode, firsts, counts, drawcount);
+}
+
+void GL_APIENTRY glMultiDrawArraysInstancedANGLE(GLenum mode,
+                                                 const GLint *firsts,
+                                                 const GLsizei *counts,
+                                                 const GLsizei *instanceCounts,
+                                                 GLsizei drawcount)
+{
+    return gl::MultiDrawArraysInstancedANGLE(mode, firsts, counts, instanceCounts, drawcount);
+}
+
+void GL_APIENTRY glMultiDrawElementsANGLE(GLenum mode,
+                                          const GLsizei *counts,
+                                          GLenum type,
+                                          const GLvoid *const *indices,
+                                          GLsizei drawcount)
+{
+    return gl::MultiDrawElementsANGLE(mode, counts, type, indices, drawcount);
+}
+
+void GL_APIENTRY glMultiDrawElementsInstancedANGLE(GLenum mode,
+                                                   const GLsizei *counts,
+                                                   GLenum type,
+                                                   const GLvoid *const *indices,
+                                                   const GLsizei *instanceCounts,
+                                                   GLsizei drawcount)
+{
+    return gl::MultiDrawElementsInstancedANGLE(mode, counts, type, indices, instanceCounts,
+                                               drawcount);
+}
+
+// GL_ANGLE_provoking_vertex
+void GL_APIENTRY glProvokingVertexANGLE(GLenum mode)
+{
+    return gl::ProvokingVertexANGLE(mode);
+}
+
+// GL_ANGLE_request_extension
+void GL_APIENTRY glRequestExtensionANGLE(const GLchar *name)
+{
+    return gl::RequestExtensionANGLE(name);
+}
+
+// GL_ANGLE_robust_client_memory
+void GL_APIENTRY glGetBooleanvRobustANGLE(GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLboolean *params)
+{
+    return gl::GetBooleanvRobustANGLE(pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetBufferParameterivRobustANGLE(GLenum target,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLint *params)
+{
+    return gl::GetBufferParameterivRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetFloatvRobustANGLE(GLenum pname,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLfloat *params)
+{
+    return gl::GetFloatvRobustANGLE(pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetFramebufferAttachmentParameterivRobustANGLE(GLenum target,
+                                                                  GLenum attachment,
+                                                                  GLenum pname,
+                                                                  GLsizei bufSize,
+                                                                  GLsizei *length,
+                                                                  GLint *params)
+{
+    return gl::GetFramebufferAttachmentParameterivRobustANGLE(target, attachment, pname, bufSize,
+                                                              length, params);
+}
+
+void GL_APIENTRY glGetIntegervRobustANGLE(GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint *data)
+{
+    return gl::GetIntegervRobustANGLE(pname, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetProgramivRobustANGLE(GLuint program,
+                                           GLenum pname,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLint *params)
+{
+    return gl::GetProgramivRobustANGLE(program, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetRenderbufferParameterivRobustANGLE(GLenum target,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLint *params)
+{
+    return gl::GetRenderbufferParameterivRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetShaderivRobustANGLE(GLuint shader,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLint *params)
+{
+    return gl::GetShaderivRobustANGLE(shader, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetTexParameterfvRobustANGLE(GLenum target,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLfloat *params)
+{
+    return gl::GetTexParameterfvRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetTexParameterivRobustANGLE(GLenum target,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *params)
+{
+    return gl::GetTexParameterivRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetUniformfvRobustANGLE(GLuint program,
+                                           GLint location,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLfloat *params)
+{
+    return gl::GetUniformfvRobustANGLE(program, location, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetUniformivRobustANGLE(GLuint program,
+                                           GLint location,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLint *params)
+{
+    return gl::GetUniformivRobustANGLE(program, location, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetVertexAttribfvRobustANGLE(GLuint index,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLfloat *params)
+{
+    return gl::GetVertexAttribfvRobustANGLE(index, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetVertexAttribivRobustANGLE(GLuint index,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *params)
+{
+    return gl::GetVertexAttribivRobustANGLE(index, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetVertexAttribPointervRobustANGLE(GLuint index,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      void **pointer)
+{
+    return gl::GetVertexAttribPointervRobustANGLE(index, pname, bufSize, length, pointer);
+}
+
+void GL_APIENTRY glReadPixelsRobustANGLE(GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLsizei *columns,
+                                         GLsizei *rows,
+                                         void *pixels)
+{
+    return gl::ReadPixelsRobustANGLE(x, y, width, height, format, type, bufSize, length, columns,
+                                     rows, pixels);
+}
+
+void GL_APIENTRY glTexImage2DRobustANGLE(GLenum target,
+                                         GLint level,
+                                         GLint internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         const void *pixels)
+{
+    return gl::TexImage2DRobustANGLE(target, level, internalformat, width, height, border, format,
+                                     type, bufSize, pixels);
+}
+
+void GL_APIENTRY glTexParameterfvRobustANGLE(GLenum target,
+                                             GLenum pname,
+                                             GLsizei bufSize,
+                                             const GLfloat *params)
+{
+    return gl::TexParameterfvRobustANGLE(target, pname, bufSize, params);
+}
+
+void GL_APIENTRY glTexParameterivRobustANGLE(GLenum target,
+                                             GLenum pname,
+                                             GLsizei bufSize,
+                                             const GLint *params)
+{
+    return gl::TexParameterivRobustANGLE(target, pname, bufSize, params);
+}
+
+void GL_APIENTRY glTexSubImage2DRobustANGLE(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            GLsizei bufSize,
+                                            const void *pixels)
+{
+    return gl::TexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width, height, format,
+                                        type, bufSize, pixels);
+}
+
+void GL_APIENTRY glTexImage3DRobustANGLE(GLenum target,
+                                         GLint level,
+                                         GLint internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type,
+                                         GLsizei bufSize,
+                                         const void *pixels)
+{
+    return gl::TexImage3DRobustANGLE(target, level, internalformat, width, height, depth, border,
+                                     format, type, bufSize, pixels);
+}
+
+void GL_APIENTRY glTexSubImage3DRobustANGLE(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLenum type,
+                                            GLsizei bufSize,
+                                            const void *pixels)
+{
+    return gl::TexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset, width, height,
+                                        depth, format, type, bufSize, pixels);
+}
+
+void GL_APIENTRY glCompressedTexImage2DRobustANGLE(GLenum target,
+                                                   GLint level,
+                                                   GLenum internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLint border,
+                                                   GLsizei imageSize,
+                                                   GLsizei dataSize,
+                                                   const GLvoid *data)
+{
+    return gl::CompressedTexImage2DRobustANGLE(target, level, internalformat, width, height, border,
+                                               imageSize, dataSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage2DRobustANGLE(GLenum target,
+                                                      GLint level,
+                                                      GLsizei xoffset,
+                                                      GLsizei yoffset,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLenum format,
+                                                      GLsizei imageSize,
+                                                      GLsizei dataSize,
+                                                      const GLvoid *data)
+{
+    return gl::CompressedTexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width, height,
+                                                  format, imageSize, dataSize, data);
+}
+
+void GL_APIENTRY glCompressedTexImage3DRobustANGLE(GLenum target,
+                                                   GLint level,
+                                                   GLenum internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height,
+                                                   GLsizei depth,
+                                                   GLint border,
+                                                   GLsizei imageSize,
+                                                   GLsizei dataSize,
+                                                   const GLvoid *data)
+{
+    return gl::CompressedTexImage3DRobustANGLE(target, level, internalformat, width, height, depth,
+                                               border, imageSize, dataSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage3DRobustANGLE(GLenum target,
+                                                      GLint level,
+                                                      GLint xoffset,
+                                                      GLint yoffset,
+                                                      GLint zoffset,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLsizei depth,
+                                                      GLenum format,
+                                                      GLsizei imageSize,
+                                                      GLsizei dataSize,
+                                                      const GLvoid *data)
+{
+    return gl::CompressedTexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset, width,
+                                                  height, depth, format, imageSize, dataSize, data);
+}
+
+void GL_APIENTRY glGetQueryivRobustANGLE(GLenum target,
+                                         GLenum pname,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLint *params)
+{
+    return gl::GetQueryivRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetQueryObjectuivRobustANGLE(GLuint id,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLuint *params)
+{
+    return gl::GetQueryObjectuivRobustANGLE(id, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetBufferPointervRobustANGLE(GLenum target,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                void **params)
+{
+    return gl::GetBufferPointervRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetIntegeri_vRobustANGLE(GLenum target,
+                                            GLuint index,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint *data)
+{
+    return gl::GetIntegeri_vRobustANGLE(target, index, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetInternalformativRobustANGLE(GLenum target,
+                                                  GLenum internalformat,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLint *params)
+{
+    return gl::GetInternalformativRobustANGLE(target, internalformat, pname, bufSize, length,
+                                              params);
+}
+
+void GL_APIENTRY glGetVertexAttribIivRobustANGLE(GLuint index,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *params)
+{
+    return gl::GetVertexAttribIivRobustANGLE(index, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetVertexAttribIuivRobustANGLE(GLuint index,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint *params)
+{
+    return gl::GetVertexAttribIuivRobustANGLE(index, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetUniformuivRobustANGLE(GLuint program,
+                                            GLint location,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLuint *params)
+{
+    return gl::GetUniformuivRobustANGLE(program, location, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetActiveUniformBlockivRobustANGLE(GLuint program,
+                                                      GLuint uniformBlockIndex,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params)
+{
+    return gl::GetActiveUniformBlockivRobustANGLE(program, uniformBlockIndex, pname, bufSize,
+                                                  length, params);
+}
+
+void GL_APIENTRY glGetInteger64vRobustANGLE(GLenum pname,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint64 *data)
+{
+    return gl::GetInteger64vRobustANGLE(pname, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetInteger64i_vRobustANGLE(GLenum target,
+                                              GLuint index,
+                                              GLsizei bufSize,
+                                              GLsizei *length,
+                                              GLint64 *data)
+{
+    return gl::GetInteger64i_vRobustANGLE(target, index, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetBufferParameteri64vRobustANGLE(GLenum target,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint64 *params)
+{
+    return gl::GetBufferParameteri64vRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glSamplerParameterivRobustANGLE(GLuint sampler,
+                                                 GLuint pname,
+                                                 GLsizei bufSize,
+                                                 const GLint *param)
+{
+    return gl::SamplerParameterivRobustANGLE(sampler, pname, bufSize, param);
+}
+
+void GL_APIENTRY glSamplerParameterfvRobustANGLE(GLuint sampler,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 const GLfloat *param)
+{
+    return gl::SamplerParameterfvRobustANGLE(sampler, pname, bufSize, param);
+}
+
+void GL_APIENTRY glGetSamplerParameterivRobustANGLE(GLuint sampler,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params)
+{
+    return gl::GetSamplerParameterivRobustANGLE(sampler, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetSamplerParameterfvRobustANGLE(GLuint sampler,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLfloat *params)
+{
+    return gl::GetSamplerParameterfvRobustANGLE(sampler, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetFramebufferParameterivRobustANGLE(GLuint sampler,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint *params)
+{
+    return gl::GetFramebufferParameterivRobustANGLE(sampler, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetProgramInterfaceivRobustANGLE(GLuint program,
+                                                    GLenum programInterface,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params)
+{
+    return gl::GetProgramInterfaceivRobustANGLE(program, programInterface, pname, bufSize, length,
+                                                params);
+}
+
+void GL_APIENTRY glGetBooleani_vRobustANGLE(GLenum target,
+                                            GLuint index,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLboolean *data)
+{
+    return gl::GetBooleani_vRobustANGLE(target, index, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetMultisamplefvRobustANGLE(GLenum pname,
+                                               GLuint index,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLfloat *val)
+{
+    return gl::GetMultisamplefvRobustANGLE(pname, index, bufSize, length, val);
+}
+
+void GL_APIENTRY glGetTexLevelParameterivRobustANGLE(GLenum target,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params)
+{
+    return gl::GetTexLevelParameterivRobustANGLE(target, level, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetTexLevelParameterfvRobustANGLE(GLenum target,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLfloat *params)
+{
+    return gl::GetTexLevelParameterfvRobustANGLE(target, level, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetPointervRobustANGLERobustANGLE(GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     void **params)
+{
+    return gl::GetPointervRobustANGLERobustANGLE(pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glReadnPixelsRobustANGLE(GLint x,
+                                          GLint y,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          GLsizei *length,
+                                          GLsizei *columns,
+                                          GLsizei *rows,
+                                          void *data)
+{
+    return gl::ReadnPixelsRobustANGLE(x, y, width, height, format, type, bufSize, length, columns,
+                                      rows, data);
+}
+
+void GL_APIENTRY glGetnUniformfvRobustANGLE(GLuint program,
+                                            GLint location,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLfloat *params)
+{
+    return gl::GetnUniformfvRobustANGLE(program, location, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetnUniformivRobustANGLE(GLuint program,
+                                            GLint location,
+                                            GLsizei bufSize,
+                                            GLsizei *length,
+                                            GLint *params)
+{
+    return gl::GetnUniformivRobustANGLE(program, location, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetnUniformuivRobustANGLE(GLuint program,
+                                             GLint location,
+                                             GLsizei bufSize,
+                                             GLsizei *length,
+                                             GLuint *params)
+{
+    return gl::GetnUniformuivRobustANGLE(program, location, bufSize, length, params);
+}
+
+void GL_APIENTRY glTexParameterIivRobustANGLE(GLenum target,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              const GLint *params)
+{
+    return gl::TexParameterIivRobustANGLE(target, pname, bufSize, params);
+}
+
+void GL_APIENTRY glTexParameterIuivRobustANGLE(GLenum target,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               const GLuint *params)
+{
+    return gl::TexParameterIuivRobustANGLE(target, pname, bufSize, params);
+}
+
+void GL_APIENTRY glGetTexParameterIivRobustANGLE(GLenum target,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint *params)
+{
+    return gl::GetTexParameterIivRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetTexParameterIuivRobustANGLE(GLenum target,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint *params)
+{
+    return gl::GetTexParameterIuivRobustANGLE(target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glSamplerParameterIivRobustANGLE(GLuint sampler,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  const GLint *param)
+{
+    return gl::SamplerParameterIivRobustANGLE(sampler, pname, bufSize, param);
+}
+
+void GL_APIENTRY glSamplerParameterIuivRobustANGLE(GLuint sampler,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   const GLuint *param)
+{
+    return gl::SamplerParameterIuivRobustANGLE(sampler, pname, bufSize, param);
+}
+
+void GL_APIENTRY glGetSamplerParameterIivRobustANGLE(GLuint sampler,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params)
+{
+    return gl::GetSamplerParameterIivRobustANGLE(sampler, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetSamplerParameterIuivRobustANGLE(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLuint *params)
+{
+    return gl::GetSamplerParameterIuivRobustANGLE(sampler, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetQueryObjectivRobustANGLE(GLuint id,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *params)
+{
+    return gl::GetQueryObjectivRobustANGLE(id, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetQueryObjecti64vRobustANGLE(GLuint id,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLint64 *params)
+{
+    return gl::GetQueryObjecti64vRobustANGLE(id, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetQueryObjectui64vRobustANGLE(GLuint id,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei *length,
+                                                  GLuint64 *params)
+{
+    return gl::GetQueryObjectui64vRobustANGLE(id, pname, bufSize, length, params);
+}
+
+// GL_ANGLE_texture_external_update
+void GL_APIENTRY glTexImage2DExternalANGLE(GLenum target,
+                                           GLint level,
+                                           GLint internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLint border,
+                                           GLenum format,
+                                           GLenum type)
+{
+    return gl::TexImage2DExternalANGLE(target, level, internalformat, width, height, border, format,
+                                       type);
+}
+
+void GL_APIENTRY glInvalidateTextureANGLE(GLenum target)
+{
+    return gl::InvalidateTextureANGLE(target);
+}
+
+// GL_ANGLE_texture_multisample
+void GL_APIENTRY glTexStorage2DMultisampleANGLE(GLenum target,
+                                                GLsizei samples,
+                                                GLenum internalformat,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLboolean fixedsamplelocations)
+{
+    return gl::TexStorage2DMultisampleANGLE(target, samples, internalformat, width, height,
+                                            fixedsamplelocations);
+}
+
+void GL_APIENTRY glGetTexLevelParameterivANGLE(GLenum target,
+                                               GLint level,
+                                               GLenum pname,
+                                               GLint *params)
+{
+    return gl::GetTexLevelParameterivANGLE(target, level, pname, params);
+}
+
+void GL_APIENTRY glGetTexLevelParameterfvANGLE(GLenum target,
+                                               GLint level,
+                                               GLenum pname,
+                                               GLfloat *params)
+{
+    return gl::GetTexLevelParameterfvANGLE(target, level, pname, params);
+}
+
+void GL_APIENTRY glGetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val)
+{
+    return gl::GetMultisamplefvANGLE(pname, index, val);
+}
+
+void GL_APIENTRY glSampleMaskiANGLE(GLuint maskNumber, GLbitfield mask)
+{
+    return gl::SampleMaskiANGLE(maskNumber, mask);
+}
+
+// GL_ANGLE_translated_shader_source
+void GL_APIENTRY glGetTranslatedShaderSourceANGLE(GLuint shader,
+                                                  GLsizei bufsize,
+                                                  GLsizei *length,
+                                                  GLchar *source)
+{
+    return gl::GetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
+}
+
+// GL_CHROMIUM_bind_uniform_location
+void GL_APIENTRY glBindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name)
+{
+    return gl::BindUniformLocationCHROMIUM(program, location, name);
+}
+
+// GL_CHROMIUM_copy_compressed_texture
+void GL_APIENTRY glCompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId)
+{
+    return gl::CompressedCopyTextureCHROMIUM(sourceId, destId);
+}
+
+// GL_CHROMIUM_copy_texture
+void GL_APIENTRY glCopyTextureCHROMIUM(GLuint sourceId,
+                                       GLint sourceLevel,
+                                       GLenum destTarget,
+                                       GLuint destId,
+                                       GLint destLevel,
+                                       GLint internalFormat,
+                                       GLenum destType,
+                                       GLboolean unpackFlipY,
+                                       GLboolean unpackPremultiplyAlpha,
+                                       GLboolean unpackUnmultiplyAlpha)
+{
+    return gl::CopyTextureCHROMIUM(sourceId, sourceLevel, destTarget, destId, destLevel,
+                                   internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha,
+                                   unpackUnmultiplyAlpha);
+}
+
+void GL_APIENTRY glCopySubTextureCHROMIUM(GLuint sourceId,
+                                          GLint sourceLevel,
+                                          GLenum destTarget,
+                                          GLuint destId,
+                                          GLint destLevel,
+                                          GLint xoffset,
+                                          GLint yoffset,
+                                          GLint x,
+                                          GLint y,
+                                          GLint width,
+                                          GLint height,
+                                          GLboolean unpackFlipY,
+                                          GLboolean unpackPremultiplyAlpha,
+                                          GLboolean unpackUnmultiplyAlpha)
+{
+    return gl::CopySubTextureCHROMIUM(sourceId, sourceLevel, destTarget, destId, destLevel, xoffset,
+                                      yoffset, x, y, width, height, unpackFlipY,
+                                      unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+// GL_CHROMIUM_framebuffer_mixed_samples
+void GL_APIENTRY glCoverageModulationCHROMIUM(GLenum components)
+{
+    return gl::CoverageModulationCHROMIUM(components);
+}
+
+void GL_APIENTRY glMatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat *matrix)
+{
+    return gl::MatrixLoadfCHROMIUM(matrixMode, matrix);
+}
+
+void GL_APIENTRY glMatrixLoadIdentityCHROMIUM(GLenum matrixMode)
+{
+    return gl::MatrixLoadIdentityCHROMIUM(matrixMode);
+}
+
+// GL_CHROMIUM_lose_context
+void GL_APIENTRY glLoseContextCHROMIUM(GLenum current, GLenum other)
+{
+    return gl::LoseContextCHROMIUM(current, other);
+}
+
+// GL_CHROMIUM_path_rendering
+GLuint GL_APIENTRY glGenPathsCHROMIUM(GLsizei range)
+{
+    return gl::GenPathsCHROMIUM(range);
+}
+
+void GL_APIENTRY glDeletePathsCHROMIUM(GLuint first, GLsizei range)
+{
+    return gl::DeletePathsCHROMIUM(first, range);
+}
+
+GLboolean GL_APIENTRY glIsPathCHROMIUM(GLuint path)
+{
+    return gl::IsPathCHROMIUM(path);
+}
+
+void GL_APIENTRY glPathCommandsCHROMIUM(GLuint path,
+                                        GLsizei numCommands,
+                                        const GLubyte *commands,
+                                        GLsizei numCoords,
+                                        GLenum coordType,
+                                        const void *coords)
+{
+    return gl::PathCommandsCHROMIUM(path, numCommands, commands, numCoords, coordType, coords);
+}
+
+void GL_APIENTRY glPathParameterfCHROMIUM(GLuint path, GLenum pname, GLfloat value)
+{
+    return gl::PathParameterfCHROMIUM(path, pname, value);
+}
+
+void GL_APIENTRY glPathParameteriCHROMIUM(GLuint path, GLenum pname, GLint value)
+{
+    return gl::PathParameteriCHROMIUM(path, pname, value);
+}
+
+void GL_APIENTRY glGetPathParameterfvCHROMIUM(GLuint path, GLenum pname, GLfloat *value)
+{
+    return gl::GetPathParameterfvCHROMIUM(path, pname, value);
+}
+
+void GL_APIENTRY glGetPathParameterivCHROMIUM(GLuint path, GLenum pname, GLint *value)
+{
+    return gl::GetPathParameterivCHROMIUM(path, pname, value);
+}
+
+void GL_APIENTRY glPathStencilFuncCHROMIUM(GLenum func, GLint ref, GLuint mask)
+{
+    return gl::PathStencilFuncCHROMIUM(func, ref, mask);
+}
+
+void GL_APIENTRY glStencilFillPathCHROMIUM(GLuint path, GLenum fillMode, GLuint mask)
+{
+    return gl::StencilFillPathCHROMIUM(path, fillMode, mask);
+}
+
+void GL_APIENTRY glStencilStrokePathCHROMIUM(GLuint path, GLint reference, GLuint mask)
+{
+    return gl::StencilStrokePathCHROMIUM(path, reference, mask);
+}
+
+void GL_APIENTRY glCoverFillPathCHROMIUM(GLuint path, GLenum coverMode)
+{
+    return gl::CoverFillPathCHROMIUM(path, coverMode);
+}
+
+void GL_APIENTRY glCoverStrokePathCHROMIUM(GLuint path, GLenum coverMode)
+{
+    return gl::CoverStrokePathCHROMIUM(path, coverMode);
+}
+
+void GL_APIENTRY glStencilThenCoverFillPathCHROMIUM(GLuint path,
+                                                    GLenum fillMode,
+                                                    GLuint mask,
+                                                    GLenum coverMode)
+{
+    return gl::StencilThenCoverFillPathCHROMIUM(path, fillMode, mask, coverMode);
+}
+
+void GL_APIENTRY glStencilThenCoverStrokePathCHROMIUM(GLuint path,
+                                                      GLint reference,
+                                                      GLuint mask,
+                                                      GLenum coverMode)
+{
+    return gl::StencilThenCoverStrokePathCHROMIUM(path, reference, mask, coverMode);
+}
+
+void GL_APIENTRY glCoverFillPathInstancedCHROMIUM(GLsizei numPath,
+                                                  GLenum pathNameType,
+                                                  const void *paths,
+                                                  GLuint pathBase,
+                                                  GLenum coverMode,
+                                                  GLenum transformType,
+                                                  const GLfloat *transformValues)
+{
+    return gl::CoverFillPathInstancedCHROMIUM(numPath, pathNameType, paths, pathBase, coverMode,
+                                              transformType, transformValues);
+}
+
+void GL_APIENTRY glCoverStrokePathInstancedCHROMIUM(GLsizei numPath,
+                                                    GLenum pathNameType,
+                                                    const void *paths,
+                                                    GLuint pathBase,
+                                                    GLenum coverMode,
+                                                    GLenum transformType,
+                                                    const GLfloat *transformValues)
+{
+    return gl::CoverStrokePathInstancedCHROMIUM(numPath, pathNameType, paths, pathBase, coverMode,
+                                                transformType, transformValues);
+}
+
+void GL_APIENTRY glStencilStrokePathInstancedCHROMIUM(GLsizei numPath,
+                                                      GLenum pathNameType,
+                                                      const void *paths,
+                                                      GLuint pathBase,
+                                                      GLint reference,
+                                                      GLuint mask,
+                                                      GLenum transformType,
+                                                      const GLfloat *transformValues)
+{
+    return gl::StencilStrokePathInstancedCHROMIUM(numPath, pathNameType, paths, pathBase, reference,
+                                                  mask, transformType, transformValues);
+}
+
+void GL_APIENTRY glStencilFillPathInstancedCHROMIUM(GLsizei numPaths,
+                                                    GLenum pathNameType,
+                                                    const void *paths,
+                                                    GLuint pathBase,
+                                                    GLenum fillMode,
+                                                    GLuint mask,
+                                                    GLenum transformType,
+                                                    const GLfloat *transformValues)
+{
+    return gl::StencilFillPathInstancedCHROMIUM(numPaths, pathNameType, paths, pathBase, fillMode,
+                                                mask, transformType, transformValues);
+}
+
+void GL_APIENTRY glStencilThenCoverFillPathInstancedCHROMIUM(GLsizei numPaths,
+                                                             GLenum pathNameType,
+                                                             const void *paths,
+                                                             GLuint pathBase,
+                                                             GLenum fillMode,
+                                                             GLuint mask,
+                                                             GLenum coverMode,
+                                                             GLenum transformType,
+                                                             const GLfloat *transformValues)
+{
+    return gl::StencilThenCoverFillPathInstancedCHROMIUM(numPaths, pathNameType, paths, pathBase,
+                                                         fillMode, mask, coverMode, transformType,
+                                                         transformValues);
+}
+
+void GL_APIENTRY glStencilThenCoverStrokePathInstancedCHROMIUM(GLsizei numPaths,
+                                                               GLenum pathNameType,
+                                                               const void *paths,
+                                                               GLuint pathBase,
+                                                               GLint reference,
+                                                               GLuint mask,
+                                                               GLenum coverMode,
+                                                               GLenum transformType,
+                                                               const GLfloat *transformValues)
+{
+    return gl::StencilThenCoverStrokePathInstancedCHROMIUM(numPaths, pathNameType, paths, pathBase,
+                                                           reference, mask, coverMode,
+                                                           transformType, transformValues);
+}
+
+void GL_APIENTRY glBindFragmentInputLocationCHROMIUM(GLuint programs,
+                                                     GLint location,
+                                                     const GLchar *name)
+{
+    return gl::BindFragmentInputLocationCHROMIUM(programs, location, name);
+}
+
+void GL_APIENTRY glProgramPathFragmentInputGenCHROMIUM(GLuint program,
+                                                       GLint location,
+                                                       GLenum genMode,
+                                                       GLint components,
+                                                       const GLfloat *coeffs)
+{
+    return gl::ProgramPathFragmentInputGenCHROMIUM(program, location, genMode, components, coeffs);
+}
+
+// GL_EXT_blend_func_extended
+void GL_APIENTRY glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
+{
+    return gl::BindFragDataLocationEXT(program, color, name);
+}
+
+void GL_APIENTRY glBindFragDataLocationIndexedEXT(GLuint program,
+                                                  GLuint colorNumber,
+                                                  GLuint index,
+                                                  const GLchar *name)
+{
+    return gl::BindFragDataLocationIndexedEXT(program, colorNumber, index, name);
+}
+
+GLint GL_APIENTRY glGetFragDataIndexEXT(GLuint program, const GLchar *name)
+{
+    return gl::GetFragDataIndexEXT(program, name);
+}
+
+GLint GL_APIENTRY glGetProgramResourceLocationIndexEXT(GLuint program,
+                                                       GLenum programInterface,
+                                                       const GLchar *name)
+{
+    return gl::GetProgramResourceLocationIndexEXT(program, programInterface, name);
+}
+
+// GL_EXT_debug_marker
+void GL_APIENTRY glInsertEventMarkerEXT(GLsizei length, const GLchar *marker)
+{
+    return gl::InsertEventMarkerEXT(length, marker);
+}
+
+void GL_APIENTRY glPopGroupMarkerEXT()
+{
+    return gl::PopGroupMarkerEXT();
+}
+
+void GL_APIENTRY glPushGroupMarkerEXT(GLsizei length, const GLchar *marker)
+{
+    return gl::PushGroupMarkerEXT(length, marker);
+}
+
+// GL_EXT_discard_framebuffer
+void GL_APIENTRY glDiscardFramebufferEXT(GLenum target,
+                                         GLsizei numAttachments,
+                                         const GLenum *attachments)
+{
+    return gl::DiscardFramebufferEXT(target, numAttachments, attachments);
+}
+
+// GL_EXT_disjoint_timer_query
+void GL_APIENTRY glBeginQueryEXT(GLenum target, GLuint id)
+{
+    return gl::BeginQueryEXT(target, id);
+}
+
+void GL_APIENTRY glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
+{
+    return gl::DeleteQueriesEXT(n, ids);
+}
+
+void GL_APIENTRY glEndQueryEXT(GLenum target)
+{
+    return gl::EndQueryEXT(target);
+}
+
+void GL_APIENTRY glGenQueriesEXT(GLsizei n, GLuint *ids)
+{
+    return gl::GenQueriesEXT(n, ids);
+}
+
+void GL_APIENTRY glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
+{
+    return gl::GetQueryObjecti64vEXT(id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
+{
+    return gl::GetQueryObjectivEXT(id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
+{
+    return gl::GetQueryObjectui64vEXT(id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
+{
+    return gl::GetQueryObjectuivEXT(id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetQueryivEXT(target, pname, params);
+}
+
+GLboolean GL_APIENTRY glIsQueryEXT(GLuint id)
+{
+    return gl::IsQueryEXT(id);
+}
+
+void GL_APIENTRY glQueryCounterEXT(GLuint id, GLenum target)
+{
+    return gl::QueryCounterEXT(id, target);
+}
+
+// GL_EXT_draw_buffers
+void GL_APIENTRY glDrawBuffersEXT(GLsizei n, const GLenum *bufs)
+{
+    return gl::DrawBuffersEXT(n, bufs);
+}
+
+// GL_EXT_geometry_shader
+void GL_APIENTRY glFramebufferTextureEXT(GLenum target,
+                                         GLenum attachment,
+                                         GLuint texture,
+                                         GLint level)
+{
+    return gl::FramebufferTextureEXT(target, attachment, texture, level);
+}
+
+// GL_EXT_instanced_arrays
+void GL_APIENTRY glDrawArraysInstancedEXT(GLenum mode,
+                                          GLint start,
+                                          GLsizei count,
+                                          GLsizei primcount)
+{
+    return gl::DrawArraysInstancedEXT(mode, start, count, primcount);
+}
+
+void GL_APIENTRY glDrawElementsInstancedEXT(GLenum mode,
+                                            GLsizei count,
+                                            GLenum type,
+                                            const void *indices,
+                                            GLsizei primcount)
+{
+    return gl::DrawElementsInstancedEXT(mode, count, type, indices, primcount);
+}
+
+void GL_APIENTRY glVertexAttribDivisorEXT(GLuint index, GLuint divisor)
+{
+    return gl::VertexAttribDivisorEXT(index, divisor);
+}
+
+// GL_EXT_map_buffer_range
+void GL_APIENTRY glFlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length)
+{
+    return gl::FlushMappedBufferRangeEXT(target, offset, length);
+}
+
+void *GL_APIENTRY glMapBufferRangeEXT(GLenum target,
+                                      GLintptr offset,
+                                      GLsizeiptr length,
+                                      GLbitfield access)
+{
+    return gl::MapBufferRangeEXT(target, offset, length, access);
+}
+
+// GL_EXT_memory_object
+void GL_APIENTRY glBufferStorageMemEXT(GLenum target,
+                                       GLsizeiptr size,
+                                       GLuint memory,
+                                       GLuint64 offset)
+{
+    return gl::BufferStorageMemEXT(target, size, memory, offset);
+}
+
+void GL_APIENTRY glCreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
+{
+    return gl::CreateMemoryObjectsEXT(n, memoryObjects);
+}
+
+void GL_APIENTRY glDeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects)
+{
+    return gl::DeleteMemoryObjectsEXT(n, memoryObjects);
+}
+
+void GL_APIENTRY glGetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params)
+{
+    return gl::GetMemoryObjectParameterivEXT(memoryObject, pname, params);
+}
+
+void GL_APIENTRY glGetUnsignedBytevEXT(GLenum pname, GLubyte *data)
+{
+    return gl::GetUnsignedBytevEXT(pname, data);
+}
+
+void GL_APIENTRY glGetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
+{
+    return gl::GetUnsignedBytei_vEXT(target, index, data);
+}
+
+GLboolean GL_APIENTRY glIsMemoryObjectEXT(GLuint memoryObject)
+{
+    return gl::IsMemoryObjectEXT(memoryObject);
+}
+
+void GL_APIENTRY glMemoryObjectParameterivEXT(GLuint memoryObject,
+                                              GLenum pname,
+                                              const GLint *params)
+{
+    return gl::MemoryObjectParameterivEXT(memoryObject, pname, params);
+}
+
+void GL_APIENTRY glTexStorageMem2DEXT(GLenum target,
+                                      GLsizei levels,
+                                      GLenum internalFormat,
+                                      GLsizei width,
+                                      GLsizei height,
+                                      GLuint memory,
+                                      GLuint64 offset)
+{
+    return gl::TexStorageMem2DEXT(target, levels, internalFormat, width, height, memory, offset);
+}
+
+void GL_APIENTRY glTexStorageMem2DMultisampleEXT(GLenum target,
+                                                 GLsizei samples,
+                                                 GLenum internalFormat,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLboolean fixedSampleLocations,
+                                                 GLuint memory,
+                                                 GLuint64 offset)
+{
+    return gl::TexStorageMem2DMultisampleEXT(target, samples, internalFormat, width, height,
+                                             fixedSampleLocations, memory, offset);
+}
+
+void GL_APIENTRY glTexStorageMem3DEXT(GLenum target,
+                                      GLsizei levels,
+                                      GLenum internalFormat,
+                                      GLsizei width,
+                                      GLsizei height,
+                                      GLsizei depth,
+                                      GLuint memory,
+                                      GLuint64 offset)
+{
+    return gl::TexStorageMem3DEXT(target, levels, internalFormat, width, height, depth, memory,
+                                  offset);
+}
+
+void GL_APIENTRY glTexStorageMem3DMultisampleEXT(GLenum target,
+                                                 GLsizei samples,
+                                                 GLenum internalFormat,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLsizei depth,
+                                                 GLboolean fixedSampleLocations,
+                                                 GLuint memory,
+                                                 GLuint64 offset)
+{
+    return gl::TexStorageMem3DMultisampleEXT(target, samples, internalFormat, width, height, depth,
+                                             fixedSampleLocations, memory, offset);
+}
+
+// GL_EXT_memory_object_fd
+void GL_APIENTRY glImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
+{
+    return gl::ImportMemoryFdEXT(memory, size, handleType, fd);
+}
+
+// GL_EXT_occlusion_query_boolean
+
+// GL_EXT_robustness
+GLenum GL_APIENTRY glGetGraphicsResetStatusEXT()
+{
+    return gl::GetGraphicsResetStatusEXT();
+}
+
+void GL_APIENTRY glGetnUniformfvEXT(GLuint program,
+                                    GLint location,
+                                    GLsizei bufSize,
+                                    GLfloat *params)
+{
+    return gl::GetnUniformfvEXT(program, location, bufSize, params);
+}
+
+void GL_APIENTRY glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params)
+{
+    return gl::GetnUniformivEXT(program, location, bufSize, params);
+}
+
+void GL_APIENTRY glReadnPixelsEXT(GLint x,
+                                  GLint y,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLenum format,
+                                  GLenum type,
+                                  GLsizei bufSize,
+                                  void *data)
+{
+    return gl::ReadnPixelsEXT(x, y, width, height, format, type, bufSize, data);
+}
+
+// GL_EXT_semaphore
+void GL_APIENTRY glDeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores)
+{
+    return gl::DeleteSemaphoresEXT(n, semaphores);
+}
+
+void GL_APIENTRY glGenSemaphoresEXT(GLsizei n, GLuint *semaphores)
+{
+    return gl::GenSemaphoresEXT(n, semaphores);
+}
+
+void GL_APIENTRY glGetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params)
+{
+    return gl::GetSemaphoreParameterui64vEXT(semaphore, pname, params);
+}
+
+GLboolean GL_APIENTRY glIsSemaphoreEXT(GLuint semaphore)
+{
+    return gl::IsSemaphoreEXT(semaphore);
+}
+
+void GL_APIENTRY glSemaphoreParameterui64vEXT(GLuint semaphore,
+                                              GLenum pname,
+                                              const GLuint64 *params)
+{
+    return gl::SemaphoreParameterui64vEXT(semaphore, pname, params);
+}
+
+void GL_APIENTRY glSignalSemaphoreEXT(GLuint semaphore,
+                                      GLuint numBufferBarriers,
+                                      const GLuint *buffers,
+                                      GLuint numTextureBarriers,
+                                      const GLuint *textures,
+                                      const GLenum *dstLayouts)
+{
+    return gl::SignalSemaphoreEXT(semaphore, numBufferBarriers, buffers, numTextureBarriers,
+                                  textures, dstLayouts);
+}
+
+void GL_APIENTRY glWaitSemaphoreEXT(GLuint semaphore,
+                                    GLuint numBufferBarriers,
+                                    const GLuint *buffers,
+                                    GLuint numTextureBarriers,
+                                    const GLuint *textures,
+                                    const GLenum *srcLayouts)
+{
+    return gl::WaitSemaphoreEXT(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures,
+                                srcLayouts);
+}
+
+// GL_EXT_semaphore_fd
+void GL_APIENTRY glImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
+{
+    return gl::ImportSemaphoreFdEXT(semaphore, handleType, fd);
+}
+
+// GL_EXT_texture_storage
+void GL_APIENTRY glTexStorage1DEXT(GLenum target,
+                                   GLsizei levels,
+                                   GLenum internalformat,
+                                   GLsizei width)
+{
+    return gl::TexStorage1DEXT(target, levels, internalformat, width);
+}
+
+void GL_APIENTRY glTexStorage2DEXT(GLenum target,
+                                   GLsizei levels,
+                                   GLenum internalformat,
+                                   GLsizei width,
+                                   GLsizei height)
+{
+    return gl::TexStorage2DEXT(target, levels, internalformat, width, height);
+}
+
+void GL_APIENTRY glTexStorage3DEXT(GLenum target,
+                                   GLsizei levels,
+                                   GLenum internalformat,
+                                   GLsizei width,
+                                   GLsizei height,
+                                   GLsizei depth)
+{
+    return gl::TexStorage3DEXT(target, levels, internalformat, width, height, depth);
+}
+
+// GL_KHR_debug
+void GL_APIENTRY glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam)
+{
+    return gl::DebugMessageCallbackKHR(callback, userParam);
+}
+
+void GL_APIENTRY glDebugMessageControlKHR(GLenum source,
+                                          GLenum type,
+                                          GLenum severity,
+                                          GLsizei count,
+                                          const GLuint *ids,
+                                          GLboolean enabled)
+{
+    return gl::DebugMessageControlKHR(source, type, severity, count, ids, enabled);
+}
+
+void GL_APIENTRY glDebugMessageInsertKHR(GLenum source,
+                                         GLenum type,
+                                         GLuint id,
+                                         GLenum severity,
+                                         GLsizei length,
+                                         const GLchar *buf)
+{
+    return gl::DebugMessageInsertKHR(source, type, id, severity, length, buf);
+}
+
+GLuint GL_APIENTRY glGetDebugMessageLogKHR(GLuint count,
+                                           GLsizei bufSize,
+                                           GLenum *sources,
+                                           GLenum *types,
+                                           GLuint *ids,
+                                           GLenum *severities,
+                                           GLsizei *lengths,
+                                           GLchar *messageLog)
+{
+    return gl::GetDebugMessageLogKHR(count, bufSize, sources, types, ids, severities, lengths,
+                                     messageLog);
+}
+
+void GL_APIENTRY
+glGetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
+{
+    return gl::GetObjectLabelKHR(identifier, name, bufSize, length, label);
+}
+
+void GL_APIENTRY glGetObjectPtrLabelKHR(const void *ptr,
+                                        GLsizei bufSize,
+                                        GLsizei *length,
+                                        GLchar *label)
+{
+    return gl::GetObjectPtrLabelKHR(ptr, bufSize, length, label);
+}
+
+void GL_APIENTRY glGetPointervKHR(GLenum pname, void **params)
+{
+    return gl::GetPointervKHR(pname, params);
+}
+
+void GL_APIENTRY glObjectLabelKHR(GLenum identifier,
+                                  GLuint name,
+                                  GLsizei length,
+                                  const GLchar *label)
+{
+    return gl::ObjectLabelKHR(identifier, name, length, label);
+}
+
+void GL_APIENTRY glObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label)
+{
+    return gl::ObjectPtrLabelKHR(ptr, length, label);
+}
+
+void GL_APIENTRY glPopDebugGroupKHR()
+{
+    return gl::PopDebugGroupKHR();
+}
+
+void GL_APIENTRY glPushDebugGroupKHR(GLenum source,
+                                     GLuint id,
+                                     GLsizei length,
+                                     const GLchar *message)
+{
+    return gl::PushDebugGroupKHR(source, id, length, message);
+}
+
+// GL_KHR_parallel_shader_compile
+void GL_APIENTRY glMaxShaderCompilerThreadsKHR(GLuint count)
+{
+    return gl::MaxShaderCompilerThreadsKHR(count);
+}
+
+// GL_NV_fence
+void GL_APIENTRY glDeleteFencesNV(GLsizei n, const GLuint *fences)
+{
+    return gl::DeleteFencesNV(n, fences);
+}
+
+void GL_APIENTRY glFinishFenceNV(GLuint fence)
+{
+    return gl::FinishFenceNV(fence);
+}
+
+void GL_APIENTRY glGenFencesNV(GLsizei n, GLuint *fences)
+{
+    return gl::GenFencesNV(n, fences);
+}
+
+void GL_APIENTRY glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
+{
+    return gl::GetFenceivNV(fence, pname, params);
+}
+
+GLboolean GL_APIENTRY glIsFenceNV(GLuint fence)
+{
+    return gl::IsFenceNV(fence);
+}
+
+void GL_APIENTRY glSetFenceNV(GLuint fence, GLenum condition)
+{
+    return gl::SetFenceNV(fence, condition);
+}
+
+GLboolean GL_APIENTRY glTestFenceNV(GLuint fence)
+{
+    return gl::TestFenceNV(fence);
+}
+
+// GL_OES_EGL_image
+void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image)
+{
+    return gl::EGLImageTargetRenderbufferStorageOES(target, image);
+}
+
+void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
+{
+    return gl::EGLImageTargetTexture2DOES(target, image);
+}
+
+// GL_OES_draw_texture
+void GL_APIENTRY glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
+{
+    return gl::DrawTexfOES(x, y, z, width, height);
+}
+
+void GL_APIENTRY glDrawTexfvOES(const GLfloat *coords)
+{
+    return gl::DrawTexfvOES(coords);
+}
+
+void GL_APIENTRY glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
+{
+    return gl::DrawTexiOES(x, y, z, width, height);
+}
+
+void GL_APIENTRY glDrawTexivOES(const GLint *coords)
+{
+    return gl::DrawTexivOES(coords);
+}
+
+void GL_APIENTRY glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
+{
+    return gl::DrawTexsOES(x, y, z, width, height);
+}
+
+void GL_APIENTRY glDrawTexsvOES(const GLshort *coords)
+{
+    return gl::DrawTexsvOES(coords);
+}
+
+void GL_APIENTRY glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
+{
+    return gl::DrawTexxOES(x, y, z, width, height);
+}
+
+void GL_APIENTRY glDrawTexxvOES(const GLfixed *coords)
+{
+    return gl::DrawTexxvOES(coords);
+}
+
+// GL_OES_framebuffer_object
+void GL_APIENTRY glBindFramebufferOES(GLenum target, GLuint framebuffer)
+{
+    return gl::BindFramebufferOES(target, framebuffer);
+}
+
+void GL_APIENTRY glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
+{
+    return gl::BindRenderbufferOES(target, renderbuffer);
+}
+
+GLenum GL_APIENTRY glCheckFramebufferStatusOES(GLenum target)
+{
+    return gl::CheckFramebufferStatusOES(target);
+}
+
+void GL_APIENTRY glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
+{
+    return gl::DeleteFramebuffersOES(n, framebuffers);
+}
+
+void GL_APIENTRY glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
+{
+    return gl::DeleteRenderbuffersOES(n, renderbuffers);
+}
+
+void GL_APIENTRY glFramebufferRenderbufferOES(GLenum target,
+                                              GLenum attachment,
+                                              GLenum renderbuffertarget,
+                                              GLuint renderbuffer)
+{
+    return gl::FramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer);
+}
+
+void GL_APIENTRY glFramebufferTexture2DOES(GLenum target,
+                                           GLenum attachment,
+                                           GLenum textarget,
+                                           GLuint texture,
+                                           GLint level)
+{
+    return gl::FramebufferTexture2DOES(target, attachment, textarget, texture, level);
+}
+
+void GL_APIENTRY glGenFramebuffersOES(GLsizei n, GLuint *framebuffers)
+{
+    return gl::GenFramebuffersOES(n, framebuffers);
+}
+
+void GL_APIENTRY glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
+{
+    return gl::GenRenderbuffersOES(n, renderbuffers);
+}
+
+void GL_APIENTRY glGenerateMipmapOES(GLenum target)
+{
+    return gl::GenerateMipmapOES(target);
+}
+
+void GL_APIENTRY glGetFramebufferAttachmentParameterivOES(GLenum target,
+                                                          GLenum attachment,
+                                                          GLenum pname,
+                                                          GLint *params)
+{
+    return gl::GetFramebufferAttachmentParameterivOES(target, attachment, pname, params);
+}
+
+void GL_APIENTRY glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetRenderbufferParameterivOES(target, pname, params);
+}
+
+GLboolean GL_APIENTRY glIsFramebufferOES(GLuint framebuffer)
+{
+    return gl::IsFramebufferOES(framebuffer);
+}
+
+GLboolean GL_APIENTRY glIsRenderbufferOES(GLuint renderbuffer)
+{
+    return gl::IsRenderbufferOES(renderbuffer);
+}
+
+void GL_APIENTRY glRenderbufferStorageOES(GLenum target,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height)
+{
+    return gl::RenderbufferStorageOES(target, internalformat, width, height);
+}
+
+// GL_OES_get_program_binary
+void GL_APIENTRY glGetProgramBinaryOES(GLuint program,
+                                       GLsizei bufSize,
+                                       GLsizei *length,
+                                       GLenum *binaryFormat,
+                                       void *binary)
+{
+    return gl::GetProgramBinaryOES(program, bufSize, length, binaryFormat, binary);
+}
+
+void GL_APIENTRY glProgramBinaryOES(GLuint program,
+                                    GLenum binaryFormat,
+                                    const void *binary,
+                                    GLint length)
+{
+    return gl::ProgramBinaryOES(program, binaryFormat, binary, length);
+}
+
+// GL_OES_mapbuffer
+void GL_APIENTRY glGetBufferPointervOES(GLenum target, GLenum pname, void **params)
+{
+    return gl::GetBufferPointervOES(target, pname, params);
+}
+
+void *GL_APIENTRY glMapBufferOES(GLenum target, GLenum access)
+{
+    return gl::MapBufferOES(target, access);
+}
+
+GLboolean GL_APIENTRY glUnmapBufferOES(GLenum target)
+{
+    return gl::UnmapBufferOES(target);
+}
+
+// GL_OES_matrix_palette
+void GL_APIENTRY glCurrentPaletteMatrixOES(GLuint matrixpaletteindex)
+{
+    return gl::CurrentPaletteMatrixOES(matrixpaletteindex);
+}
+
+void GL_APIENTRY glLoadPaletteFromModelViewMatrixOES()
+{
+    return gl::LoadPaletteFromModelViewMatrixOES();
+}
+
+void GL_APIENTRY glMatrixIndexPointerOES(GLint size,
+                                         GLenum type,
+                                         GLsizei stride,
+                                         const void *pointer)
+{
+    return gl::MatrixIndexPointerOES(size, type, stride, pointer);
+}
+
+void GL_APIENTRY glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer)
+{
+    return gl::WeightPointerOES(size, type, stride, pointer);
+}
+
+// GL_OES_point_size_array
+void GL_APIENTRY glPointSizePointerOES(GLenum type, GLsizei stride, const void *pointer)
+{
+    return gl::PointSizePointerOES(type, stride, pointer);
+}
+
+// GL_OES_query_matrix
+GLbitfield GL_APIENTRY glQueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
+{
+    return gl::QueryMatrixxOES(mantissa, exponent);
+}
+
+// GL_OES_texture_3D
+void GL_APIENTRY glCompressedTexImage3DOES(GLenum target,
+                                           GLint level,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth,
+                                           GLint border,
+                                           GLsizei imageSize,
+                                           const void *data)
+{
+    return gl::CompressedTexImage3DOES(target, level, internalformat, width, height, depth, border,
+                                       imageSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage3DOES(GLenum target,
+                                              GLint level,
+                                              GLint xoffset,
+                                              GLint yoffset,
+                                              GLint zoffset,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLsizei depth,
+                                              GLenum format,
+                                              GLsizei imageSize,
+                                              const void *data)
+{
+    return gl::CompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height,
+                                          depth, format, imageSize, data);
+}
+
+void GL_APIENTRY glCopyTexSubImage3DOES(GLenum target,
+                                        GLint level,
+                                        GLint xoffset,
+                                        GLint yoffset,
+                                        GLint zoffset,
+                                        GLint x,
+                                        GLint y,
+                                        GLsizei width,
+                                        GLsizei height)
+{
+    return gl::CopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+}
+
+void GL_APIENTRY glFramebufferTexture3DOES(GLenum target,
+                                           GLenum attachment,
+                                           GLenum textarget,
+                                           GLuint texture,
+                                           GLint level,
+                                           GLint zoffset)
+{
+    return gl::FramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset);
+}
+
+void GL_APIENTRY glTexImage3DOES(GLenum target,
+                                 GLint level,
+                                 GLenum internalformat,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLsizei depth,
+                                 GLint border,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void *pixels)
+{
+    return gl::TexImage3DOES(target, level, internalformat, width, height, depth, border, format,
+                             type, pixels);
+}
+
+void GL_APIENTRY glTexSubImage3DOES(GLenum target,
+                                    GLint level,
+                                    GLint xoffset,
+                                    GLint yoffset,
+                                    GLint zoffset,
+                                    GLsizei width,
+                                    GLsizei height,
+                                    GLsizei depth,
+                                    GLenum format,
+                                    GLenum type,
+                                    const void *pixels)
+{
+    return gl::TexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth,
+                                format, type, pixels);
+}
+
+// GL_OES_texture_border_clamp
+void GL_APIENTRY glGetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params)
+{
+    return gl::GetSamplerParameterIivOES(sampler, pname, params);
+}
+
+void GL_APIENTRY glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params)
+{
+    return gl::GetSamplerParameterIuivOES(sampler, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameterIivOES(GLenum target, GLenum pname, GLint *params)
+{
+    return gl::GetTexParameterIivOES(target, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params)
+{
+    return gl::GetTexParameterIuivOES(target, pname, params);
+}
+
+void GL_APIENTRY glSamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param)
+{
+    return gl::SamplerParameterIivOES(sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param)
+{
+    return gl::SamplerParameterIuivOES(sampler, pname, param);
+}
+
+void GL_APIENTRY glTexParameterIivOES(GLenum target, GLenum pname, const GLint *params)
+{
+    return gl::TexParameterIivOES(target, pname, params);
+}
+
+void GL_APIENTRY glTexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params)
+{
+    return gl::TexParameterIuivOES(target, pname, params);
+}
+
+// GL_OES_texture_cube_map
+void GL_APIENTRY glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params)
+{
+    return gl::GetTexGenfvOES(coord, pname, params);
+}
+
+void GL_APIENTRY glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params)
+{
+    return gl::GetTexGenivOES(coord, pname, params);
+}
+
+void GL_APIENTRY glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
+{
+    return gl::GetTexGenxvOES(coord, pname, params);
+}
+
+void GL_APIENTRY glTexGenfOES(GLenum coord, GLenum pname, GLfloat param)
+{
+    return gl::TexGenfOES(coord, pname, param);
+}
+
+void GL_APIENTRY glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params)
+{
+    return gl::TexGenfvOES(coord, pname, params);
+}
+
+void GL_APIENTRY glTexGeniOES(GLenum coord, GLenum pname, GLint param)
+{
+    return gl::TexGeniOES(coord, pname, param);
+}
+
+void GL_APIENTRY glTexGenivOES(GLenum coord, GLenum pname, const GLint *params)
+{
+    return gl::TexGenivOES(coord, pname, params);
+}
+
+void GL_APIENTRY glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
+{
+    return gl::TexGenxOES(coord, pname, param);
+}
+
+void GL_APIENTRY glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
+{
+    return gl::TexGenxvOES(coord, pname, params);
+}
+
+// GL_OES_texture_storage_multisample_2d_array
+void GL_APIENTRY glTexStorage3DMultisampleOES(GLenum target,
+                                              GLsizei samples,
+                                              GLenum internalformat,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLsizei depth,
+                                              GLboolean fixedsamplelocations)
+{
+    return gl::TexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth,
+                                          fixedsamplelocations);
+}
+
+// GL_OES_vertex_array_object
+void GL_APIENTRY glBindVertexArrayOES(GLuint array)
+{
+    return gl::BindVertexArrayOES(array);
+}
+
+void GL_APIENTRY glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
+{
+    return gl::DeleteVertexArraysOES(n, arrays);
+}
+
+void GL_APIENTRY glGenVertexArraysOES(GLsizei n, GLuint *arrays)
+{
+    return gl::GenVertexArraysOES(n, arrays);
+}
+
+GLboolean GL_APIENTRY glIsVertexArrayOES(GLuint array)
+{
+    return gl::IsVertexArrayOES(array);
+}
+
+// GL_OVR_multiview
+void GL_APIENTRY glFramebufferTextureMultiviewOVR(GLenum target,
+                                                  GLenum attachment,
+                                                  GLuint texture,
+                                                  GLint level,
+                                                  GLint baseViewIndex,
+                                                  GLsizei numViews)
+{
+    return gl::FramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex,
+                                              numViews);
+}
+
+// GL_OVR_multiview2
+
+// EGL_ANGLE_explicit_context
+void GL_APIENTRY glActiveShaderProgramContextANGLE(GLeglContext ctx,
+                                                   GLuint pipeline,
+                                                   GLuint program)
+{
+    return gl::ActiveShaderProgramContextANGLE(ctx, pipeline, program);
+}
+
+void GL_APIENTRY glActiveTextureContextANGLE(GLeglContext ctx, GLenum texture)
+{
+    return gl::ActiveTextureContextANGLE(ctx, texture);
+}
+
+void GL_APIENTRY glAlphaFuncContextANGLE(GLeglContext ctx, GLenum func, GLfloat ref)
+{
+    return gl::AlphaFuncContextANGLE(ctx, func, ref);
+}
+
+void GL_APIENTRY glAlphaFuncxContextANGLE(GLeglContext ctx, GLenum func, GLfixed ref)
+{
+    return gl::AlphaFuncxContextANGLE(ctx, func, ref);
+}
+
+void GL_APIENTRY glAttachShaderContextANGLE(GLeglContext ctx, GLuint program, GLuint shader)
+{
+    return gl::AttachShaderContextANGLE(ctx, program, shader);
+}
+
+void GL_APIENTRY glBeginQueryContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
+{
+    return gl::BeginQueryContextANGLE(ctx, target, id);
+}
+
+void GL_APIENTRY glBeginQueryEXTContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
+{
+    return gl::BeginQueryEXTContextANGLE(ctx, target, id);
+}
+
+void GL_APIENTRY glBeginTransformFeedbackContextANGLE(GLeglContext ctx, GLenum primitiveMode)
+{
+    return gl::BeginTransformFeedbackContextANGLE(ctx, primitiveMode);
+}
+
+void GL_APIENTRY glBindAttribLocationContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  GLuint index,
+                                                  const GLchar *name)
+{
+    return gl::BindAttribLocationContextANGLE(ctx, program, index, name);
+}
+
+void GL_APIENTRY glBindBufferContextANGLE(GLeglContext ctx, GLenum target, GLuint buffer)
+{
+    return gl::BindBufferContextANGLE(ctx, target, buffer);
+}
+
+void GL_APIENTRY glBindBufferBaseContextANGLE(GLeglContext ctx,
+                                              GLenum target,
+                                              GLuint index,
+                                              GLuint buffer)
+{
+    return gl::BindBufferBaseContextANGLE(ctx, target, index, buffer);
+}
+
+void GL_APIENTRY glBindBufferRangeContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLuint index,
+                                               GLuint buffer,
+                                               GLintptr offset,
+                                               GLsizeiptr size)
+{
+    return gl::BindBufferRangeContextANGLE(ctx, target, index, buffer, offset, size);
+}
+
+void GL_APIENTRY glBindFragDataLocationEXTContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLuint color,
+                                                       const GLchar *name)
+{
+    return gl::BindFragDataLocationEXTContextANGLE(ctx, program, color, name);
+}
+
+void GL_APIENTRY glBindFragDataLocationIndexedEXTContextANGLE(GLeglContext ctx,
+                                                              GLuint program,
+                                                              GLuint colorNumber,
+                                                              GLuint index,
+                                                              const GLchar *name)
+{
+    return gl::BindFragDataLocationIndexedEXTContextANGLE(ctx, program, colorNumber, index, name);
+}
+
+void GL_APIENTRY glBindFramebufferContextANGLE(GLeglContext ctx, GLenum target, GLuint framebuffer)
+{
+    return gl::BindFramebufferContextANGLE(ctx, target, framebuffer);
+}
+
+void GL_APIENTRY glBindFramebufferOESContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLuint framebuffer)
+{
+    return gl::BindFramebufferOESContextANGLE(ctx, target, framebuffer);
+}
+
+void GL_APIENTRY glBindImageTextureContextANGLE(GLeglContext ctx,
+                                                GLuint unit,
+                                                GLuint texture,
+                                                GLint level,
+                                                GLboolean layered,
+                                                GLint layer,
+                                                GLenum access,
+                                                GLenum format)
+{
+    return gl::BindImageTextureContextANGLE(ctx, unit, texture, level, layered, layer, access,
+                                            format);
+}
+
+void GL_APIENTRY glBindProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
+{
+    return gl::BindProgramPipelineContextANGLE(ctx, pipeline);
+}
+
+void GL_APIENTRY glBindRenderbufferContextANGLE(GLeglContext ctx,
+                                                GLenum target,
+                                                GLuint renderbuffer)
+{
+    return gl::BindRenderbufferContextANGLE(ctx, target, renderbuffer);
+}
+
+void GL_APIENTRY glBindRenderbufferOESContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLuint renderbuffer)
+{
+    return gl::BindRenderbufferOESContextANGLE(ctx, target, renderbuffer);
+}
+
+void GL_APIENTRY glBindSamplerContextANGLE(GLeglContext ctx, GLuint unit, GLuint sampler)
+{
+    return gl::BindSamplerContextANGLE(ctx, unit, sampler);
+}
+
+void GL_APIENTRY glBindTextureContextANGLE(GLeglContext ctx, GLenum target, GLuint texture)
+{
+    return gl::BindTextureContextANGLE(ctx, target, texture);
+}
+
+void GL_APIENTRY glBindTransformFeedbackContextANGLE(GLeglContext ctx, GLenum target, GLuint id)
+{
+    return gl::BindTransformFeedbackContextANGLE(ctx, target, id);
+}
+
+void GL_APIENTRY glBindVertexArrayContextANGLE(GLeglContext ctx, GLuint array)
+{
+    return gl::BindVertexArrayContextANGLE(ctx, array);
+}
+
+void GL_APIENTRY glBindVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array)
+{
+    return gl::BindVertexArrayOESContextANGLE(ctx, array);
+}
+
+void GL_APIENTRY glBindVertexBufferContextANGLE(GLeglContext ctx,
+                                                GLuint bindingindex,
+                                                GLuint buffer,
+                                                GLintptr offset,
+                                                GLsizei stride)
+{
+    return gl::BindVertexBufferContextANGLE(ctx, bindingindex, buffer, offset, stride);
+}
+
+void GL_APIENTRY
+glBlendColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    return gl::BlendColorContextANGLE(ctx, red, green, blue, alpha);
+}
+
+void GL_APIENTRY glBlendEquationContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    return gl::BlendEquationContextANGLE(ctx, mode);
+}
+
+void GL_APIENTRY glBlendEquationSeparateContextANGLE(GLeglContext ctx,
+                                                     GLenum modeRGB,
+                                                     GLenum modeAlpha)
+{
+    return gl::BlendEquationSeparateContextANGLE(ctx, modeRGB, modeAlpha);
+}
+
+void GL_APIENTRY glBlendFuncContextANGLE(GLeglContext ctx, GLenum sfactor, GLenum dfactor)
+{
+    return gl::BlendFuncContextANGLE(ctx, sfactor, dfactor);
+}
+
+void GL_APIENTRY glBlendFuncSeparateContextANGLE(GLeglContext ctx,
+                                                 GLenum sfactorRGB,
+                                                 GLenum dfactorRGB,
+                                                 GLenum sfactorAlpha,
+                                                 GLenum dfactorAlpha)
+{
+    return gl::BlendFuncSeparateContextANGLE(ctx, sfactorRGB, dfactorRGB, sfactorAlpha,
+                                             dfactorAlpha);
+}
+
+void GL_APIENTRY glBlitFramebufferContextANGLE(GLeglContext ctx,
+                                               GLint srcX0,
+                                               GLint srcY0,
+                                               GLint srcX1,
+                                               GLint srcY1,
+                                               GLint dstX0,
+                                               GLint dstY0,
+                                               GLint dstX1,
+                                               GLint dstY1,
+                                               GLbitfield mask,
+                                               GLenum filter)
+{
+    return gl::BlitFramebufferContextANGLE(ctx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
+                                           dstY1, mask, filter);
+}
+
+void GL_APIENTRY glBlitFramebufferANGLEContextANGLE(GLeglContext ctx,
+                                                    GLint srcX0,
+                                                    GLint srcY0,
+                                                    GLint srcX1,
+                                                    GLint srcY1,
+                                                    GLint dstX0,
+                                                    GLint dstY0,
+                                                    GLint dstX1,
+                                                    GLint dstY1,
+                                                    GLbitfield mask,
+                                                    GLenum filter)
+{
+    return gl::BlitFramebufferANGLEContextANGLE(ctx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+                                                dstX1, dstY1, mask, filter);
+}
+
+void GL_APIENTRY glBufferDataContextANGLE(GLeglContext ctx,
+                                          GLenum target,
+                                          GLsizeiptr size,
+                                          const void *data,
+                                          GLenum usage)
+{
+    return gl::BufferDataContextANGLE(ctx, target, size, data, usage);
+}
+
+void GL_APIENTRY glBufferStorageMemEXTContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLsizeiptr size,
+                                                   GLuint memory,
+                                                   GLuint64 offset)
+{
+    return gl::BufferStorageMemEXTContextANGLE(ctx, target, size, memory, offset);
+}
+
+void GL_APIENTRY glBufferSubDataContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLintptr offset,
+                                             GLsizeiptr size,
+                                             const void *data)
+{
+    return gl::BufferSubDataContextANGLE(ctx, target, offset, size, data);
+}
+
+GLenum GL_APIENTRY glCheckFramebufferStatusContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::CheckFramebufferStatusContextANGLE(ctx, target);
+}
+
+GLenum GL_APIENTRY glCheckFramebufferStatusOESContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::CheckFramebufferStatusOESContextANGLE(ctx, target);
+}
+
+void GL_APIENTRY glClearContextANGLE(GLeglContext ctx, GLbitfield mask)
+{
+    return gl::ClearContextANGLE(ctx, mask);
+}
+
+void GL_APIENTRY glClearBufferfiContextANGLE(GLeglContext ctx,
+                                             GLenum buffer,
+                                             GLint drawbuffer,
+                                             GLfloat depth,
+                                             GLint stencil)
+{
+    return gl::ClearBufferfiContextANGLE(ctx, buffer, drawbuffer, depth, stencil);
+}
+
+void GL_APIENTRY glClearBufferfvContextANGLE(GLeglContext ctx,
+                                             GLenum buffer,
+                                             GLint drawbuffer,
+                                             const GLfloat *value)
+{
+    return gl::ClearBufferfvContextANGLE(ctx, buffer, drawbuffer, value);
+}
+
+void GL_APIENTRY glClearBufferivContextANGLE(GLeglContext ctx,
+                                             GLenum buffer,
+                                             GLint drawbuffer,
+                                             const GLint *value)
+{
+    return gl::ClearBufferivContextANGLE(ctx, buffer, drawbuffer, value);
+}
+
+void GL_APIENTRY glClearBufferuivContextANGLE(GLeglContext ctx,
+                                              GLenum buffer,
+                                              GLint drawbuffer,
+                                              const GLuint *value)
+{
+    return gl::ClearBufferuivContextANGLE(ctx, buffer, drawbuffer, value);
+}
+
+void GL_APIENTRY
+glClearColorContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    return gl::ClearColorContextANGLE(ctx, red, green, blue, alpha);
+}
+
+void GL_APIENTRY
+glClearColorxContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+    return gl::ClearColorxContextANGLE(ctx, red, green, blue, alpha);
+}
+
+void GL_APIENTRY glClearDepthfContextANGLE(GLeglContext ctx, GLfloat d)
+{
+    return gl::ClearDepthfContextANGLE(ctx, d);
+}
+
+void GL_APIENTRY glClearDepthxContextANGLE(GLeglContext ctx, GLfixed depth)
+{
+    return gl::ClearDepthxContextANGLE(ctx, depth);
+}
+
+void GL_APIENTRY glClearStencilContextANGLE(GLeglContext ctx, GLint s)
+{
+    return gl::ClearStencilContextANGLE(ctx, s);
+}
+
+void GL_APIENTRY glClientActiveTextureContextANGLE(GLeglContext ctx, GLenum texture)
+{
+    return gl::ClientActiveTextureContextANGLE(ctx, texture);
+}
+
+GLenum GL_APIENTRY glClientWaitSyncContextANGLE(GLeglContext ctx,
+                                                GLsync sync,
+                                                GLbitfield flags,
+                                                GLuint64 timeout)
+{
+    return gl::ClientWaitSyncContextANGLE(ctx, sync, flags, timeout);
+}
+
+void GL_APIENTRY glClipPlanefContextANGLE(GLeglContext ctx, GLenum p, const GLfloat *eqn)
+{
+    return gl::ClipPlanefContextANGLE(ctx, p, eqn);
+}
+
+void GL_APIENTRY glClipPlanexContextANGLE(GLeglContext ctx, GLenum plane, const GLfixed *equation)
+{
+    return gl::ClipPlanexContextANGLE(ctx, plane, equation);
+}
+
+void GL_APIENTRY
+glColor4fContextANGLE(GLeglContext ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    return gl::Color4fContextANGLE(ctx, red, green, blue, alpha);
+}
+
+void GL_APIENTRY
+glColor4ubContextANGLE(GLeglContext ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+{
+    return gl::Color4ubContextANGLE(ctx, red, green, blue, alpha);
+}
+
+void GL_APIENTRY
+glColor4xContextANGLE(GLeglContext ctx, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
+{
+    return gl::Color4xContextANGLE(ctx, red, green, blue, alpha);
+}
+
+void GL_APIENTRY glColorMaskContextANGLE(GLeglContext ctx,
+                                         GLboolean red,
+                                         GLboolean green,
+                                         GLboolean blue,
+                                         GLboolean alpha)
+{
+    return gl::ColorMaskContextANGLE(ctx, red, green, blue, alpha);
+}
+
+void GL_APIENTRY glColorPointerContextANGLE(GLeglContext ctx,
+                                            GLint size,
+                                            GLenum type,
+                                            GLsizei stride,
+                                            const void *pointer)
+{
+    return gl::ColorPointerContextANGLE(ctx, size, type, stride, pointer);
+}
+
+void GL_APIENTRY glCompileShaderContextANGLE(GLeglContext ctx, GLuint shader)
+{
+    return gl::CompileShaderContextANGLE(ctx, shader);
+}
+
+void GL_APIENTRY glCompressedTexImage2DContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLint level,
+                                                    GLenum internalformat,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLint border,
+                                                    GLsizei imageSize,
+                                                    const void *data)
+{
+    return gl::CompressedTexImage2DContextANGLE(ctx, target, level, internalformat, width, height,
+                                                border, imageSize, data);
+}
+
+void GL_APIENTRY glCompressedTexImage3DContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLint level,
+                                                    GLenum internalformat,
+                                                    GLsizei width,
+                                                    GLsizei height,
+                                                    GLsizei depth,
+                                                    GLint border,
+                                                    GLsizei imageSize,
+                                                    const void *data)
+{
+    return gl::CompressedTexImage3DContextANGLE(ctx, target, level, internalformat, width, height,
+                                                depth, border, imageSize, data);
+}
+
+void GL_APIENTRY glCompressedTexImage3DOESContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLint level,
+                                                       GLenum internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLsizei depth,
+                                                       GLint border,
+                                                       GLsizei imageSize,
+                                                       const void *data)
+{
+    return gl::CompressedTexImage3DOESContextANGLE(ctx, target, level, internalformat, width,
+                                                   height, depth, border, imageSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage2DContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLint level,
+                                                       GLint xoffset,
+                                                       GLint yoffset,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLenum format,
+                                                       GLsizei imageSize,
+                                                       const void *data)
+{
+    return gl::CompressedTexSubImage2DContextANGLE(ctx, target, level, xoffset, yoffset, width,
+                                                   height, format, imageSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage3DContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLint level,
+                                                       GLint xoffset,
+                                                       GLint yoffset,
+                                                       GLint zoffset,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLsizei depth,
+                                                       GLenum format,
+                                                       GLsizei imageSize,
+                                                       const void *data)
+{
+    return gl::CompressedTexSubImage3DContextANGLE(ctx, target, level, xoffset, yoffset, zoffset,
+                                                   width, height, depth, format, imageSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLint level,
+                                                          GLint xoffset,
+                                                          GLint yoffset,
+                                                          GLint zoffset,
+                                                          GLsizei width,
+                                                          GLsizei height,
+                                                          GLsizei depth,
+                                                          GLenum format,
+                                                          GLsizei imageSize,
+                                                          const void *data)
+{
+    return gl::CompressedTexSubImage3DOESContextANGLE(ctx, target, level, xoffset, yoffset, zoffset,
+                                                      width, height, depth, format, imageSize,
+                                                      data);
+}
+
+void GL_APIENTRY glCopyBufferSubDataContextANGLE(GLeglContext ctx,
+                                                 GLenum readTarget,
+                                                 GLenum writeTarget,
+                                                 GLintptr readOffset,
+                                                 GLintptr writeOffset,
+                                                 GLsizeiptr size)
+{
+    return gl::CopyBufferSubDataContextANGLE(ctx, readTarget, writeTarget, readOffset, writeOffset,
+                                             size);
+}
+
+void GL_APIENTRY glCopyTexImage2DContextANGLE(GLeglContext ctx,
+                                              GLenum target,
+                                              GLint level,
+                                              GLenum internalformat,
+                                              GLint x,
+                                              GLint y,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLint border)
+{
+    return gl::CopyTexImage2DContextANGLE(ctx, target, level, internalformat, x, y, width, height,
+                                          border);
+}
+
+void GL_APIENTRY glCopyTexSubImage2DContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLint level,
+                                                 GLint xoffset,
+                                                 GLint yoffset,
+                                                 GLint x,
+                                                 GLint y,
+                                                 GLsizei width,
+                                                 GLsizei height)
+{
+    return gl::CopyTexSubImage2DContextANGLE(ctx, target, level, xoffset, yoffset, x, y, width,
+                                             height);
+}
+
+void GL_APIENTRY glCopyTexSubImage3DContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLint level,
+                                                 GLint xoffset,
+                                                 GLint yoffset,
+                                                 GLint zoffset,
+                                                 GLint x,
+                                                 GLint y,
+                                                 GLsizei width,
+                                                 GLsizei height)
+{
+    return gl::CopyTexSubImage3DContextANGLE(ctx, target, level, xoffset, yoffset, zoffset, x, y,
+                                             width, height);
+}
+
+void GL_APIENTRY glCopyTexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLint level,
+                                                    GLint xoffset,
+                                                    GLint yoffset,
+                                                    GLint zoffset,
+                                                    GLint x,
+                                                    GLint y,
+                                                    GLsizei width,
+                                                    GLsizei height)
+{
+    return gl::CopyTexSubImage3DOESContextANGLE(ctx, target, level, xoffset, yoffset, zoffset, x, y,
+                                                width, height);
+}
+
+void GL_APIENTRY glCreateMemoryObjectsEXTContextANGLE(GLeglContext ctx,
+                                                      GLsizei n,
+                                                      GLuint *memoryObjects)
+{
+    return gl::CreateMemoryObjectsEXTContextANGLE(ctx, n, memoryObjects);
+}
+
+GLuint GL_APIENTRY glCreateProgramContextANGLE(GLeglContext ctx)
+{
+    return gl::CreateProgramContextANGLE(ctx);
+}
+
+GLuint GL_APIENTRY glCreateShaderContextANGLE(GLeglContext ctx, GLenum type)
+{
+    return gl::CreateShaderContextANGLE(ctx, type);
+}
+
+GLuint GL_APIENTRY glCreateShaderProgramvContextANGLE(GLeglContext ctx,
+                                                      GLenum type,
+                                                      GLsizei count,
+                                                      const GLchar *const *strings)
+{
+    return gl::CreateShaderProgramvContextANGLE(ctx, type, count, strings);
+}
+
+void GL_APIENTRY glCullFaceContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    return gl::CullFaceContextANGLE(ctx, mode);
+}
+
+void GL_APIENTRY glCurrentPaletteMatrixOESContextANGLE(GLeglContext ctx, GLuint matrixpaletteindex)
+{
+    return gl::CurrentPaletteMatrixOESContextANGLE(ctx, matrixpaletteindex);
+}
+
+void GL_APIENTRY glDebugMessageCallbackKHRContextANGLE(GLeglContext ctx,
+                                                       GLDEBUGPROCKHR callback,
+                                                       const void *userParam)
+{
+    return gl::DebugMessageCallbackKHRContextANGLE(ctx, callback, userParam);
+}
+
+void GL_APIENTRY glDebugMessageControlKHRContextANGLE(GLeglContext ctx,
+                                                      GLenum source,
+                                                      GLenum type,
+                                                      GLenum severity,
+                                                      GLsizei count,
+                                                      const GLuint *ids,
+                                                      GLboolean enabled)
+{
+    return gl::DebugMessageControlKHRContextANGLE(ctx, source, type, severity, count, ids, enabled);
+}
+
+void GL_APIENTRY glDebugMessageInsertKHRContextANGLE(GLeglContext ctx,
+                                                     GLenum source,
+                                                     GLenum type,
+                                                     GLuint id,
+                                                     GLenum severity,
+                                                     GLsizei length,
+                                                     const GLchar *buf)
+{
+    return gl::DebugMessageInsertKHRContextANGLE(ctx, source, type, id, severity, length, buf);
+}
+
+void GL_APIENTRY glDeleteBuffersContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *buffers)
+{
+    return gl::DeleteBuffersContextANGLE(ctx, n, buffers);
+}
+
+void GL_APIENTRY glDeleteFencesNVContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *fences)
+{
+    return gl::DeleteFencesNVContextANGLE(ctx, n, fences);
+}
+
+void GL_APIENTRY glDeleteFramebuffersContextANGLE(GLeglContext ctx,
+                                                  GLsizei n,
+                                                  const GLuint *framebuffers)
+{
+    return gl::DeleteFramebuffersContextANGLE(ctx, n, framebuffers);
+}
+
+void GL_APIENTRY glDeleteFramebuffersOESContextANGLE(GLeglContext ctx,
+                                                     GLsizei n,
+                                                     const GLuint *framebuffers)
+{
+    return gl::DeleteFramebuffersOESContextANGLE(ctx, n, framebuffers);
+}
+
+void GL_APIENTRY glDeleteMemoryObjectsEXTContextANGLE(GLeglContext ctx,
+                                                      GLsizei n,
+                                                      const GLuint *memoryObjects)
+{
+    return gl::DeleteMemoryObjectsEXTContextANGLE(ctx, n, memoryObjects);
+}
+
+void GL_APIENTRY glDeleteProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    return gl::DeleteProgramContextANGLE(ctx, program);
+}
+
+void GL_APIENTRY glDeleteProgramPipelinesContextANGLE(GLeglContext ctx,
+                                                      GLsizei n,
+                                                      const GLuint *pipelines)
+{
+    return gl::DeleteProgramPipelinesContextANGLE(ctx, n, pipelines);
+}
+
+void GL_APIENTRY glDeleteQueriesContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *ids)
+{
+    return gl::DeleteQueriesContextANGLE(ctx, n, ids);
+}
+
+void GL_APIENTRY glDeleteQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *ids)
+{
+    return gl::DeleteQueriesEXTContextANGLE(ctx, n, ids);
+}
+
+void GL_APIENTRY glDeleteRenderbuffersContextANGLE(GLeglContext ctx,
+                                                   GLsizei n,
+                                                   const GLuint *renderbuffers)
+{
+    return gl::DeleteRenderbuffersContextANGLE(ctx, n, renderbuffers);
+}
+
+void GL_APIENTRY glDeleteRenderbuffersOESContextANGLE(GLeglContext ctx,
+                                                      GLsizei n,
+                                                      const GLuint *renderbuffers)
+{
+    return gl::DeleteRenderbuffersOESContextANGLE(ctx, n, renderbuffers);
+}
+
+void GL_APIENTRY glDeleteSamplersContextANGLE(GLeglContext ctx,
+                                              GLsizei count,
+                                              const GLuint *samplers)
+{
+    return gl::DeleteSamplersContextANGLE(ctx, count, samplers);
+}
+
+void GL_APIENTRY glDeleteSemaphoresEXTContextANGLE(GLeglContext ctx,
+                                                   GLsizei n,
+                                                   const GLuint *semaphores)
+{
+    return gl::DeleteSemaphoresEXTContextANGLE(ctx, n, semaphores);
+}
+
+void GL_APIENTRY glDeleteShaderContextANGLE(GLeglContext ctx, GLuint shader)
+{
+    return gl::DeleteShaderContextANGLE(ctx, shader);
+}
+
+void GL_APIENTRY glDeleteSyncContextANGLE(GLeglContext ctx, GLsync sync)
+{
+    return gl::DeleteSyncContextANGLE(ctx, sync);
+}
+
+void GL_APIENTRY glDeleteTexturesContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *textures)
+{
+    return gl::DeleteTexturesContextANGLE(ctx, n, textures);
+}
+
+void GL_APIENTRY glDeleteTransformFeedbacksContextANGLE(GLeglContext ctx,
+                                                        GLsizei n,
+                                                        const GLuint *ids)
+{
+    return gl::DeleteTransformFeedbacksContextANGLE(ctx, n, ids);
+}
+
+void GL_APIENTRY glDeleteVertexArraysContextANGLE(GLeglContext ctx, GLsizei n, const GLuint *arrays)
+{
+    return gl::DeleteVertexArraysContextANGLE(ctx, n, arrays);
+}
+
+void GL_APIENTRY glDeleteVertexArraysOESContextANGLE(GLeglContext ctx,
+                                                     GLsizei n,
+                                                     const GLuint *arrays)
+{
+    return gl::DeleteVertexArraysOESContextANGLE(ctx, n, arrays);
+}
+
+void GL_APIENTRY glDepthFuncContextANGLE(GLeglContext ctx, GLenum func)
+{
+    return gl::DepthFuncContextANGLE(ctx, func);
+}
+
+void GL_APIENTRY glDepthMaskContextANGLE(GLeglContext ctx, GLboolean flag)
+{
+    return gl::DepthMaskContextANGLE(ctx, flag);
+}
+
+void GL_APIENTRY glDepthRangefContextANGLE(GLeglContext ctx, GLfloat n, GLfloat f)
+{
+    return gl::DepthRangefContextANGLE(ctx, n, f);
+}
+
+void GL_APIENTRY glDepthRangexContextANGLE(GLeglContext ctx, GLfixed n, GLfixed f)
+{
+    return gl::DepthRangexContextANGLE(ctx, n, f);
+}
+
+void GL_APIENTRY glDetachShaderContextANGLE(GLeglContext ctx, GLuint program, GLuint shader)
+{
+    return gl::DetachShaderContextANGLE(ctx, program, shader);
+}
+
+void GL_APIENTRY glDisableContextANGLE(GLeglContext ctx, GLenum cap)
+{
+    return gl::DisableContextANGLE(ctx, cap);
+}
+
+void GL_APIENTRY glDisableClientStateContextANGLE(GLeglContext ctx, GLenum array)
+{
+    return gl::DisableClientStateContextANGLE(ctx, array);
+}
+
+void GL_APIENTRY glDisableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index)
+{
+    return gl::DisableVertexAttribArrayContextANGLE(ctx, index);
+}
+
+void GL_APIENTRY glDiscardFramebufferEXTContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLsizei numAttachments,
+                                                     const GLenum *attachments)
+{
+    return gl::DiscardFramebufferEXTContextANGLE(ctx, target, numAttachments, attachments);
+}
+
+void GL_APIENTRY glDispatchComputeContextANGLE(GLeglContext ctx,
+                                               GLuint num_groups_x,
+                                               GLuint num_groups_y,
+                                               GLuint num_groups_z)
+{
+    return gl::DispatchComputeContextANGLE(ctx, num_groups_x, num_groups_y, num_groups_z);
+}
+
+void GL_APIENTRY glDispatchComputeIndirectContextANGLE(GLeglContext ctx, GLintptr indirect)
+{
+    return gl::DispatchComputeIndirectContextANGLE(ctx, indirect);
+}
+
+void GL_APIENTRY glDrawArraysContextANGLE(GLeglContext ctx, GLenum mode, GLint first, GLsizei count)
+{
+    return gl::DrawArraysContextANGLE(ctx, mode, first, count);
+}
+
+void GL_APIENTRY glDrawArraysIndirectContextANGLE(GLeglContext ctx,
+                                                  GLenum mode,
+                                                  const void *indirect)
+{
+    return gl::DrawArraysIndirectContextANGLE(ctx, mode, indirect);
+}
+
+void GL_APIENTRY glDrawArraysInstancedContextANGLE(GLeglContext ctx,
+                                                   GLenum mode,
+                                                   GLint first,
+                                                   GLsizei count,
+                                                   GLsizei instancecount)
+{
+    return gl::DrawArraysInstancedContextANGLE(ctx, mode, first, count, instancecount);
+}
+
+void GL_APIENTRY glDrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum mode,
+                                                        GLint first,
+                                                        GLsizei count,
+                                                        GLsizei primcount)
+{
+    return gl::DrawArraysInstancedANGLEContextANGLE(ctx, mode, first, count, primcount);
+}
+
+void GL_APIENTRY glDrawArraysInstancedEXTContextANGLE(GLeglContext ctx,
+                                                      GLenum mode,
+                                                      GLint start,
+                                                      GLsizei count,
+                                                      GLsizei primcount)
+{
+    return gl::DrawArraysInstancedEXTContextANGLE(ctx, mode, start, count, primcount);
+}
+
+void GL_APIENTRY glDrawBuffersContextANGLE(GLeglContext ctx, GLsizei n, const GLenum *bufs)
+{
+    return gl::DrawBuffersContextANGLE(ctx, n, bufs);
+}
+
+void GL_APIENTRY glDrawBuffersEXTContextANGLE(GLeglContext ctx, GLsizei n, const GLenum *bufs)
+{
+    return gl::DrawBuffersEXTContextANGLE(ctx, n, bufs);
+}
+
+void GL_APIENTRY glDrawElementsContextANGLE(GLeglContext ctx,
+                                            GLenum mode,
+                                            GLsizei count,
+                                            GLenum type,
+                                            const void *indices)
+{
+    return gl::DrawElementsContextANGLE(ctx, mode, count, type, indices);
+}
+
+void GL_APIENTRY glDrawElementsIndirectContextANGLE(GLeglContext ctx,
+                                                    GLenum mode,
+                                                    GLenum type,
+                                                    const void *indirect)
+{
+    return gl::DrawElementsIndirectContextANGLE(ctx, mode, type, indirect);
+}
+
+void GL_APIENTRY glDrawElementsInstancedContextANGLE(GLeglContext ctx,
+                                                     GLenum mode,
+                                                     GLsizei count,
+                                                     GLenum type,
+                                                     const void *indices,
+                                                     GLsizei instancecount)
+{
+    return gl::DrawElementsInstancedContextANGLE(ctx, mode, count, type, indices, instancecount);
+}
+
+void GL_APIENTRY glDrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                          GLenum mode,
+                                                          GLsizei count,
+                                                          GLenum type,
+                                                          const void *indices,
+                                                          GLsizei primcount)
+{
+    return gl::DrawElementsInstancedANGLEContextANGLE(ctx, mode, count, type, indices, primcount);
+}
+
+void GL_APIENTRY glDrawElementsInstancedEXTContextANGLE(GLeglContext ctx,
+                                                        GLenum mode,
+                                                        GLsizei count,
+                                                        GLenum type,
+                                                        const void *indices,
+                                                        GLsizei primcount)
+{
+    return gl::DrawElementsInstancedEXTContextANGLE(ctx, mode, count, type, indices, primcount);
+}
+
+void GL_APIENTRY glDrawRangeElementsContextANGLE(GLeglContext ctx,
+                                                 GLenum mode,
+                                                 GLuint start,
+                                                 GLuint end,
+                                                 GLsizei count,
+                                                 GLenum type,
+                                                 const void *indices)
+{
+    return gl::DrawRangeElementsContextANGLE(ctx, mode, start, end, count, type, indices);
+}
+
+void GL_APIENTRY glDrawTexfOESContextANGLE(GLeglContext ctx,
+                                           GLfloat x,
+                                           GLfloat y,
+                                           GLfloat z,
+                                           GLfloat width,
+                                           GLfloat height)
+{
+    return gl::DrawTexfOESContextANGLE(ctx, x, y, z, width, height);
+}
+
+void GL_APIENTRY glDrawTexfvOESContextANGLE(GLeglContext ctx, const GLfloat *coords)
+{
+    return gl::DrawTexfvOESContextANGLE(ctx, coords);
+}
+
+void GL_APIENTRY
+glDrawTexiOESContextANGLE(GLeglContext ctx, GLint x, GLint y, GLint z, GLint width, GLint height)
+{
+    return gl::DrawTexiOESContextANGLE(ctx, x, y, z, width, height);
+}
+
+void GL_APIENTRY glDrawTexivOESContextANGLE(GLeglContext ctx, const GLint *coords)
+{
+    return gl::DrawTexivOESContextANGLE(ctx, coords);
+}
+
+void GL_APIENTRY glDrawTexsOESContextANGLE(GLeglContext ctx,
+                                           GLshort x,
+                                           GLshort y,
+                                           GLshort z,
+                                           GLshort width,
+                                           GLshort height)
+{
+    return gl::DrawTexsOESContextANGLE(ctx, x, y, z, width, height);
+}
+
+void GL_APIENTRY glDrawTexsvOESContextANGLE(GLeglContext ctx, const GLshort *coords)
+{
+    return gl::DrawTexsvOESContextANGLE(ctx, coords);
+}
+
+void GL_APIENTRY glDrawTexxOESContextANGLE(GLeglContext ctx,
+                                           GLfixed x,
+                                           GLfixed y,
+                                           GLfixed z,
+                                           GLfixed width,
+                                           GLfixed height)
+{
+    return gl::DrawTexxOESContextANGLE(ctx, x, y, z, width, height);
+}
+
+void GL_APIENTRY glDrawTexxvOESContextANGLE(GLeglContext ctx, const GLfixed *coords)
+{
+    return gl::DrawTexxvOESContextANGLE(ctx, coords);
+}
+
+void GL_APIENTRY glEGLImageTargetRenderbufferStorageOESContextANGLE(GLeglContext ctx,
+                                                                    GLenum target,
+                                                                    GLeglImageOES image)
+{
+    return gl::EGLImageTargetRenderbufferStorageOESContextANGLE(ctx, target, image);
+}
+
+void GL_APIENTRY glEGLImageTargetTexture2DOESContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLeglImageOES image)
+{
+    return gl::EGLImageTargetTexture2DOESContextANGLE(ctx, target, image);
+}
+
+void GL_APIENTRY glEnableContextANGLE(GLeglContext ctx, GLenum cap)
+{
+    return gl::EnableContextANGLE(ctx, cap);
+}
+
+void GL_APIENTRY glEnableClientStateContextANGLE(GLeglContext ctx, GLenum array)
+{
+    return gl::EnableClientStateContextANGLE(ctx, array);
+}
+
+void GL_APIENTRY glEnableVertexAttribArrayContextANGLE(GLeglContext ctx, GLuint index)
+{
+    return gl::EnableVertexAttribArrayContextANGLE(ctx, index);
+}
+
+void GL_APIENTRY glEndQueryContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::EndQueryContextANGLE(ctx, target);
+}
+
+void GL_APIENTRY glEndQueryEXTContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::EndQueryEXTContextANGLE(ctx, target);
+}
+
+void GL_APIENTRY glEndTransformFeedbackContextANGLE(GLeglContext ctx)
+{
+    return gl::EndTransformFeedbackContextANGLE(ctx);
+}
+
+GLsync GL_APIENTRY glFenceSyncContextANGLE(GLeglContext ctx, GLenum condition, GLbitfield flags)
+{
+    return gl::FenceSyncContextANGLE(ctx, condition, flags);
+}
+
+void GL_APIENTRY glFinishContextANGLE(GLeglContext ctx)
+{
+    return gl::FinishContextANGLE(ctx);
+}
+
+void GL_APIENTRY glFinishFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
+{
+    return gl::FinishFenceNVContextANGLE(ctx, fence);
+}
+
+void GL_APIENTRY glFlushContextANGLE(GLeglContext ctx)
+{
+    return gl::FlushContextANGLE(ctx);
+}
+
+void GL_APIENTRY glFlushMappedBufferRangeContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLintptr offset,
+                                                      GLsizeiptr length)
+{
+    return gl::FlushMappedBufferRangeContextANGLE(ctx, target, offset, length);
+}
+
+void GL_APIENTRY glFlushMappedBufferRangeEXTContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLintptr offset,
+                                                         GLsizeiptr length)
+{
+    return gl::FlushMappedBufferRangeEXTContextANGLE(ctx, target, offset, length);
+}
+
+void GL_APIENTRY glFogfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
+{
+    return gl::FogfContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glFogfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
+{
+    return gl::FogfvContextANGLE(ctx, pname, params);
+}
+
+void GL_APIENTRY glFogxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
+{
+    return gl::FogxContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glFogxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *param)
+{
+    return gl::FogxvContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glFramebufferParameteriContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum pname,
+                                                     GLint param)
+{
+    return gl::FramebufferParameteriContextANGLE(ctx, target, pname, param);
+}
+
+void GL_APIENTRY glFramebufferRenderbufferContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLenum attachment,
+                                                       GLenum renderbuffertarget,
+                                                       GLuint renderbuffer)
+{
+    return gl::FramebufferRenderbufferContextANGLE(ctx, target, attachment, renderbuffertarget,
+                                                   renderbuffer);
+}
+
+void GL_APIENTRY glFramebufferRenderbufferOESContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLenum attachment,
+                                                          GLenum renderbuffertarget,
+                                                          GLuint renderbuffer)
+{
+    return gl::FramebufferRenderbufferOESContextANGLE(ctx, target, attachment, renderbuffertarget,
+                                                      renderbuffer);
+}
+
+void GL_APIENTRY glFramebufferTexture2DContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLenum attachment,
+                                                    GLenum textarget,
+                                                    GLuint texture,
+                                                    GLint level)
+{
+    return gl::FramebufferTexture2DContextANGLE(ctx, target, attachment, textarget, texture, level);
+}
+
+void GL_APIENTRY glFramebufferTexture2DOESContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLenum attachment,
+                                                       GLenum textarget,
+                                                       GLuint texture,
+                                                       GLint level)
+{
+    return gl::FramebufferTexture2DOESContextANGLE(ctx, target, attachment, textarget, texture,
+                                                   level);
+}
+
+void GL_APIENTRY glFramebufferTexture3DOESContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLenum attachment,
+                                                       GLenum textarget,
+                                                       GLuint texture,
+                                                       GLint level,
+                                                       GLint zoffset)
+{
+    return gl::FramebufferTexture3DOESContextANGLE(ctx, target, attachment, textarget, texture,
+                                                   level, zoffset);
+}
+
+void GL_APIENTRY glFramebufferTextureEXTContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum attachment,
+                                                     GLuint texture,
+                                                     GLint level)
+{
+    return gl::FramebufferTextureEXTContextANGLE(ctx, target, attachment, texture, level);
+}
+
+void GL_APIENTRY glFramebufferTextureLayerContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLenum attachment,
+                                                       GLuint texture,
+                                                       GLint level,
+                                                       GLint layer)
+{
+    return gl::FramebufferTextureLayerContextANGLE(ctx, target, attachment, texture, level, layer);
+}
+
+void GL_APIENTRY glFramebufferTextureMultiviewOVRContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLenum attachment,
+                                                              GLuint texture,
+                                                              GLint level,
+                                                              GLint baseViewIndex,
+                                                              GLsizei numViews)
+{
+    return gl::FramebufferTextureMultiviewOVRContextANGLE(ctx, target, attachment, texture, level,
+                                                          baseViewIndex, numViews);
+}
+
+void GL_APIENTRY glFrontFaceContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    return gl::FrontFaceContextANGLE(ctx, mode);
+}
+
+void GL_APIENTRY glFrustumfContextANGLE(GLeglContext ctx,
+                                        GLfloat l,
+                                        GLfloat r,
+                                        GLfloat b,
+                                        GLfloat t,
+                                        GLfloat n,
+                                        GLfloat f)
+{
+    return gl::FrustumfContextANGLE(ctx, l, r, b, t, n, f);
+}
+
+void GL_APIENTRY glFrustumxContextANGLE(GLeglContext ctx,
+                                        GLfixed l,
+                                        GLfixed r,
+                                        GLfixed b,
+                                        GLfixed t,
+                                        GLfixed n,
+                                        GLfixed f)
+{
+    return gl::FrustumxContextANGLE(ctx, l, r, b, t, n, f);
+}
+
+void GL_APIENTRY glGenBuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *buffers)
+{
+    return gl::GenBuffersContextANGLE(ctx, n, buffers);
+}
+
+void GL_APIENTRY glGenFencesNVContextANGLE(GLeglContext ctx, GLsizei n, GLuint *fences)
+{
+    return gl::GenFencesNVContextANGLE(ctx, n, fences);
+}
+
+void GL_APIENTRY glGenFramebuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *framebuffers)
+{
+    return gl::GenFramebuffersContextANGLE(ctx, n, framebuffers);
+}
+
+void GL_APIENTRY glGenFramebuffersOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *framebuffers)
+{
+    return gl::GenFramebuffersOESContextANGLE(ctx, n, framebuffers);
+}
+
+void GL_APIENTRY glGenProgramPipelinesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *pipelines)
+{
+    return gl::GenProgramPipelinesContextANGLE(ctx, n, pipelines);
+}
+
+void GL_APIENTRY glGenQueriesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
+{
+    return gl::GenQueriesContextANGLE(ctx, n, ids);
+}
+
+void GL_APIENTRY glGenQueriesEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
+{
+    return gl::GenQueriesEXTContextANGLE(ctx, n, ids);
+}
+
+void GL_APIENTRY glGenRenderbuffersContextANGLE(GLeglContext ctx, GLsizei n, GLuint *renderbuffers)
+{
+    return gl::GenRenderbuffersContextANGLE(ctx, n, renderbuffers);
+}
+
+void GL_APIENTRY glGenRenderbuffersOESContextANGLE(GLeglContext ctx,
+                                                   GLsizei n,
+                                                   GLuint *renderbuffers)
+{
+    return gl::GenRenderbuffersOESContextANGLE(ctx, n, renderbuffers);
+}
+
+void GL_APIENTRY glGenSamplersContextANGLE(GLeglContext ctx, GLsizei count, GLuint *samplers)
+{
+    return gl::GenSamplersContextANGLE(ctx, count, samplers);
+}
+
+void GL_APIENTRY glGenSemaphoresEXTContextANGLE(GLeglContext ctx, GLsizei n, GLuint *semaphores)
+{
+    return gl::GenSemaphoresEXTContextANGLE(ctx, n, semaphores);
+}
+
+void GL_APIENTRY glGenTexturesContextANGLE(GLeglContext ctx, GLsizei n, GLuint *textures)
+{
+    return gl::GenTexturesContextANGLE(ctx, n, textures);
+}
+
+void GL_APIENTRY glGenTransformFeedbacksContextANGLE(GLeglContext ctx, GLsizei n, GLuint *ids)
+{
+    return gl::GenTransformFeedbacksContextANGLE(ctx, n, ids);
+}
+
+void GL_APIENTRY glGenVertexArraysContextANGLE(GLeglContext ctx, GLsizei n, GLuint *arrays)
+{
+    return gl::GenVertexArraysContextANGLE(ctx, n, arrays);
+}
+
+void GL_APIENTRY glGenVertexArraysOESContextANGLE(GLeglContext ctx, GLsizei n, GLuint *arrays)
+{
+    return gl::GenVertexArraysOESContextANGLE(ctx, n, arrays);
+}
+
+void GL_APIENTRY glGenerateMipmapContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::GenerateMipmapContextANGLE(ctx, target);
+}
+
+void GL_APIENTRY glGenerateMipmapOESContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::GenerateMipmapOESContextANGLE(ctx, target);
+}
+
+void GL_APIENTRY glGetActiveAttribContextANGLE(GLeglContext ctx,
+                                               GLuint program,
+                                               GLuint index,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLint *size,
+                                               GLenum *type,
+                                               GLchar *name)
+{
+    return gl::GetActiveAttribContextANGLE(ctx, program, index, bufSize, length, size, type, name);
+}
+
+void GL_APIENTRY glGetActiveUniformContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLuint index,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLint *size,
+                                                GLenum *type,
+                                                GLchar *name)
+{
+    return gl::GetActiveUniformContextANGLE(ctx, program, index, bufSize, length, size, type, name);
+}
+
+void GL_APIENTRY glGetActiveUniformBlockNameContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLuint uniformBlockIndex,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLchar *uniformBlockName)
+{
+    return gl::GetActiveUniformBlockNameContextANGLE(ctx, program, uniformBlockIndex, bufSize,
+                                                     length, uniformBlockName);
+}
+
+void GL_APIENTRY glGetActiveUniformBlockivContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLuint uniformBlockIndex,
+                                                       GLenum pname,
+                                                       GLint *params)
+{
+    return gl::GetActiveUniformBlockivContextANGLE(ctx, program, uniformBlockIndex, pname, params);
+}
+
+void GL_APIENTRY glGetActiveUniformsivContextANGLE(GLeglContext ctx,
+                                                   GLuint program,
+                                                   GLsizei uniformCount,
+                                                   const GLuint *uniformIndices,
+                                                   GLenum pname,
+                                                   GLint *params)
+{
+    return gl::GetActiveUniformsivContextANGLE(ctx, program, uniformCount, uniformIndices, pname,
+                                               params);
+}
+
+void GL_APIENTRY glGetAttachedShadersContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  GLsizei maxCount,
+                                                  GLsizei *count,
+                                                  GLuint *shaders)
+{
+    return gl::GetAttachedShadersContextANGLE(ctx, program, maxCount, count, shaders);
+}
+
+GLint GL_APIENTRY glGetAttribLocationContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  const GLchar *name)
+{
+    return gl::GetAttribLocationContextANGLE(ctx, program, name);
+}
+
+void GL_APIENTRY glGetBooleani_vContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLuint index,
+                                             GLboolean *data)
+{
+    return gl::GetBooleani_vContextANGLE(ctx, target, index, data);
+}
+
+void GL_APIENTRY glGetBooleanvContextANGLE(GLeglContext ctx, GLenum pname, GLboolean *data)
+{
+    return gl::GetBooleanvContextANGLE(ctx, pname, data);
+}
+
+void GL_APIENTRY glGetBufferParameteri64vContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLenum pname,
+                                                      GLint64 *params)
+{
+    return gl::GetBufferParameteri64vContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetBufferParameterivContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLenum pname,
+                                                    GLint *params)
+{
+    return gl::GetBufferParameterivContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetBufferPointervContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLenum pname,
+                                                 void **params)
+{
+    return gl::GetBufferPointervContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetBufferPointervOESContextANGLE(GLeglContext ctx,
+                                                    GLenum target,
+                                                    GLenum pname,
+                                                    void **params)
+{
+    return gl::GetBufferPointervOESContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetClipPlanefContextANGLE(GLeglContext ctx, GLenum plane, GLfloat *equation)
+{
+    return gl::GetClipPlanefContextANGLE(ctx, plane, equation);
+}
+
+void GL_APIENTRY glGetClipPlanexContextANGLE(GLeglContext ctx, GLenum plane, GLfixed *equation)
+{
+    return gl::GetClipPlanexContextANGLE(ctx, plane, equation);
+}
+
+GLuint GL_APIENTRY glGetDebugMessageLogKHRContextANGLE(GLeglContext ctx,
+                                                       GLuint count,
+                                                       GLsizei bufSize,
+                                                       GLenum *sources,
+                                                       GLenum *types,
+                                                       GLuint *ids,
+                                                       GLenum *severities,
+                                                       GLsizei *lengths,
+                                                       GLchar *messageLog)
+{
+    return gl::GetDebugMessageLogKHRContextANGLE(ctx, count, bufSize, sources, types, ids,
+                                                 severities, lengths, messageLog);
+}
+
+GLenum GL_APIENTRY glGetErrorContextANGLE(GLeglContext ctx)
+{
+    return gl::GetErrorContextANGLE(ctx);
+}
+
+void GL_APIENTRY glGetFenceivNVContextANGLE(GLeglContext ctx,
+                                            GLuint fence,
+                                            GLenum pname,
+                                            GLint *params)
+{
+    return gl::GetFenceivNVContextANGLE(ctx, fence, pname, params);
+}
+
+void GL_APIENTRY glGetFixedvContextANGLE(GLeglContext ctx, GLenum pname, GLfixed *params)
+{
+    return gl::GetFixedvContextANGLE(ctx, pname, params);
+}
+
+void GL_APIENTRY glGetFloatvContextANGLE(GLeglContext ctx, GLenum pname, GLfloat *data)
+{
+    return gl::GetFloatvContextANGLE(ctx, pname, data);
+}
+
+GLint GL_APIENTRY glGetFragDataIndexEXTContextANGLE(GLeglContext ctx,
+                                                    GLuint program,
+                                                    const GLchar *name)
+{
+    return gl::GetFragDataIndexEXTContextANGLE(ctx, program, name);
+}
+
+GLint GL_APIENTRY glGetFragDataLocationContextANGLE(GLeglContext ctx,
+                                                    GLuint program,
+                                                    const GLchar *name)
+{
+    return gl::GetFragDataLocationContextANGLE(ctx, program, name);
+}
+
+void GL_APIENTRY glGetFramebufferAttachmentParameterivContextANGLE(GLeglContext ctx,
+                                                                   GLenum target,
+                                                                   GLenum attachment,
+                                                                   GLenum pname,
+                                                                   GLint *params)
+{
+    return gl::GetFramebufferAttachmentParameterivContextANGLE(ctx, target, attachment, pname,
+                                                               params);
+}
+
+void GL_APIENTRY glGetFramebufferAttachmentParameterivOESContextANGLE(GLeglContext ctx,
+                                                                      GLenum target,
+                                                                      GLenum attachment,
+                                                                      GLenum pname,
+                                                                      GLint *params)
+{
+    return gl::GetFramebufferAttachmentParameterivOESContextANGLE(ctx, target, attachment, pname,
+                                                                  params);
+}
+
+void GL_APIENTRY glGetFramebufferParameterivContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         GLint *params)
+{
+    return gl::GetFramebufferParameterivContextANGLE(ctx, target, pname, params);
+}
+
+GLenum GL_APIENTRY glGetGraphicsResetStatusEXTContextANGLE(GLeglContext ctx)
+{
+    return gl::GetGraphicsResetStatusEXTContextANGLE(ctx);
+}
+
+void GL_APIENTRY glGetInteger64i_vContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLuint index,
+                                               GLint64 *data)
+{
+    return gl::GetInteger64i_vContextANGLE(ctx, target, index, data);
+}
+
+void GL_APIENTRY glGetInteger64vContextANGLE(GLeglContext ctx, GLenum pname, GLint64 *data)
+{
+    return gl::GetInteger64vContextANGLE(ctx, pname, data);
+}
+
+void GL_APIENTRY glGetIntegeri_vContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLuint index,
+                                             GLint *data)
+{
+    return gl::GetIntegeri_vContextANGLE(ctx, target, index, data);
+}
+
+void GL_APIENTRY glGetIntegervContextANGLE(GLeglContext ctx, GLenum pname, GLint *data)
+{
+    return gl::GetIntegervContextANGLE(ctx, pname, data);
+}
+
+void GL_APIENTRY glGetInternalformativContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum internalformat,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLint *params)
+{
+    return gl::GetInternalformativContextANGLE(ctx, target, internalformat, pname, bufSize, params);
+}
+
+void GL_APIENTRY glGetLightfvContextANGLE(GLeglContext ctx,
+                                          GLenum light,
+                                          GLenum pname,
+                                          GLfloat *params)
+{
+    return gl::GetLightfvContextANGLE(ctx, light, pname, params);
+}
+
+void GL_APIENTRY glGetLightxvContextANGLE(GLeglContext ctx,
+                                          GLenum light,
+                                          GLenum pname,
+                                          GLfixed *params)
+{
+    return gl::GetLightxvContextANGLE(ctx, light, pname, params);
+}
+
+void GL_APIENTRY glGetMaterialfvContextANGLE(GLeglContext ctx,
+                                             GLenum face,
+                                             GLenum pname,
+                                             GLfloat *params)
+{
+    return gl::GetMaterialfvContextANGLE(ctx, face, pname, params);
+}
+
+void GL_APIENTRY glGetMaterialxvContextANGLE(GLeglContext ctx,
+                                             GLenum face,
+                                             GLenum pname,
+                                             GLfixed *params)
+{
+    return gl::GetMaterialxvContextANGLE(ctx, face, pname, params);
+}
+
+void GL_APIENTRY glGetMemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
+                                                             GLuint memoryObject,
+                                                             GLenum pname,
+                                                             GLint *params)
+{
+    return gl::GetMemoryObjectParameterivEXTContextANGLE(ctx, memoryObject, pname, params);
+}
+
+void GL_APIENTRY glGetMultisamplefvContextANGLE(GLeglContext ctx,
+                                                GLenum pname,
+                                                GLuint index,
+                                                GLfloat *val)
+{
+    return gl::GetMultisamplefvContextANGLE(ctx, pname, index, val);
+}
+
+void GL_APIENTRY glGetObjectLabelKHRContextANGLE(GLeglContext ctx,
+                                                 GLenum identifier,
+                                                 GLuint name,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLchar *label)
+{
+    return gl::GetObjectLabelKHRContextANGLE(ctx, identifier, name, bufSize, length, label);
+}
+
+void GL_APIENTRY glGetObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
+                                                    const void *ptr,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLchar *label)
+{
+    return gl::GetObjectPtrLabelKHRContextANGLE(ctx, ptr, bufSize, length, label);
+}
+
+void GL_APIENTRY glGetPointervContextANGLE(GLeglContext ctx, GLenum pname, void **params)
+{
+    return gl::GetPointervContextANGLE(ctx, pname, params);
+}
+
+void GL_APIENTRY glGetPointervKHRContextANGLE(GLeglContext ctx, GLenum pname, void **params)
+{
+    return gl::GetPointervKHRContextANGLE(ctx, pname, params);
+}
+
+void GL_APIENTRY glGetProgramBinaryContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLenum *binaryFormat,
+                                                void *binary)
+{
+    return gl::GetProgramBinaryContextANGLE(ctx, program, bufSize, length, binaryFormat, binary);
+}
+
+void GL_APIENTRY glGetProgramBinaryOESContextANGLE(GLeglContext ctx,
+                                                   GLuint program,
+                                                   GLsizei bufSize,
+                                                   GLsizei *length,
+                                                   GLenum *binaryFormat,
+                                                   void *binary)
+{
+    return gl::GetProgramBinaryOESContextANGLE(ctx, program, bufSize, length, binaryFormat, binary);
+}
+
+void GL_APIENTRY glGetProgramInfoLogContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLsizei bufSize,
+                                                 GLsizei *length,
+                                                 GLchar *infoLog)
+{
+    return gl::GetProgramInfoLogContextANGLE(ctx, program, bufSize, length, infoLog);
+}
+
+void GL_APIENTRY glGetProgramInterfaceivContextANGLE(GLeglContext ctx,
+                                                     GLuint program,
+                                                     GLenum programInterface,
+                                                     GLenum pname,
+                                                     GLint *params)
+{
+    return gl::GetProgramInterfaceivContextANGLE(ctx, program, programInterface, pname, params);
+}
+
+void GL_APIENTRY glGetProgramPipelineInfoLogContextANGLE(GLeglContext ctx,
+                                                         GLuint pipeline,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLchar *infoLog)
+{
+    return gl::GetProgramPipelineInfoLogContextANGLE(ctx, pipeline, bufSize, length, infoLog);
+}
+
+void GL_APIENTRY glGetProgramPipelineivContextANGLE(GLeglContext ctx,
+                                                    GLuint pipeline,
+                                                    GLenum pname,
+                                                    GLint *params)
+{
+    return gl::GetProgramPipelineivContextANGLE(ctx, pipeline, pname, params);
+}
+
+GLuint GL_APIENTRY glGetProgramResourceIndexContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLenum programInterface,
+                                                         const GLchar *name)
+{
+    return gl::GetProgramResourceIndexContextANGLE(ctx, program, programInterface, name);
+}
+
+GLint GL_APIENTRY glGetProgramResourceLocationContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLenum programInterface,
+                                                           const GLchar *name)
+{
+    return gl::GetProgramResourceLocationContextANGLE(ctx, program, programInterface, name);
+}
+
+GLint GL_APIENTRY glGetProgramResourceLocationIndexEXTContextANGLE(GLeglContext ctx,
+                                                                   GLuint program,
+                                                                   GLenum programInterface,
+                                                                   const GLchar *name)
+{
+    return gl::GetProgramResourceLocationIndexEXTContextANGLE(ctx, program, programInterface, name);
+}
+
+void GL_APIENTRY glGetProgramResourceNameContextANGLE(GLeglContext ctx,
+                                                      GLuint program,
+                                                      GLenum programInterface,
+                                                      GLuint index,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLchar *name)
+{
+    return gl::GetProgramResourceNameContextANGLE(ctx, program, programInterface, index, bufSize,
+                                                  length, name);
+}
+
+void GL_APIENTRY glGetProgramResourceivContextANGLE(GLeglContext ctx,
+                                                    GLuint program,
+                                                    GLenum programInterface,
+                                                    GLuint index,
+                                                    GLsizei propCount,
+                                                    const GLenum *props,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLint *params)
+{
+    return gl::GetProgramResourceivContextANGLE(ctx, program, programInterface, index, propCount,
+                                                props, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetProgramivContextANGLE(GLeglContext ctx,
+                                            GLuint program,
+                                            GLenum pname,
+                                            GLint *params)
+{
+    return gl::GetProgramivContextANGLE(ctx, program, pname, params);
+}
+
+void GL_APIENTRY glGetQueryObjecti64vEXTContextANGLE(GLeglContext ctx,
+                                                     GLuint id,
+                                                     GLenum pname,
+                                                     GLint64 *params)
+{
+    return gl::GetQueryObjecti64vEXTContextANGLE(ctx, id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryObjectivEXTContextANGLE(GLeglContext ctx,
+                                                   GLuint id,
+                                                   GLenum pname,
+                                                   GLint *params)
+{
+    return gl::GetQueryObjectivEXTContextANGLE(ctx, id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryObjectui64vEXTContextANGLE(GLeglContext ctx,
+                                                      GLuint id,
+                                                      GLenum pname,
+                                                      GLuint64 *params)
+{
+    return gl::GetQueryObjectui64vEXTContextANGLE(ctx, id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryObjectuivContextANGLE(GLeglContext ctx,
+                                                 GLuint id,
+                                                 GLenum pname,
+                                                 GLuint *params)
+{
+    return gl::GetQueryObjectuivContextANGLE(ctx, id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryObjectuivEXTContextANGLE(GLeglContext ctx,
+                                                    GLuint id,
+                                                    GLenum pname,
+                                                    GLuint *params)
+{
+    return gl::GetQueryObjectuivEXTContextANGLE(ctx, id, pname, params);
+}
+
+void GL_APIENTRY glGetQueryivContextANGLE(GLeglContext ctx,
+                                          GLenum target,
+                                          GLenum pname,
+                                          GLint *params)
+{
+    return gl::GetQueryivContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetQueryivEXTContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLenum pname,
+                                             GLint *params)
+{
+    return gl::GetQueryivEXTContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetRenderbufferParameterivContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLenum pname,
+                                                          GLint *params)
+{
+    return gl::GetRenderbufferParameterivContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetRenderbufferParameterivOESContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLenum pname,
+                                                             GLint *params)
+{
+    return gl::GetRenderbufferParameterivOESContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetSamplerParameterIivOESContextANGLE(GLeglContext ctx,
+                                                         GLuint sampler,
+                                                         GLenum pname,
+                                                         GLint *params)
+{
+    return gl::GetSamplerParameterIivOESContextANGLE(ctx, sampler, pname, params);
+}
+
+void GL_APIENTRY glGetSamplerParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                          GLuint sampler,
+                                                          GLenum pname,
+                                                          GLuint *params)
+{
+    return gl::GetSamplerParameterIuivOESContextANGLE(ctx, sampler, pname, params);
+}
+
+void GL_APIENTRY glGetSamplerParameterfvContextANGLE(GLeglContext ctx,
+                                                     GLuint sampler,
+                                                     GLenum pname,
+                                                     GLfloat *params)
+{
+    return gl::GetSamplerParameterfvContextANGLE(ctx, sampler, pname, params);
+}
+
+void GL_APIENTRY glGetSamplerParameterivContextANGLE(GLeglContext ctx,
+                                                     GLuint sampler,
+                                                     GLenum pname,
+                                                     GLint *params)
+{
+    return gl::GetSamplerParameterivContextANGLE(ctx, sampler, pname, params);
+}
+
+void GL_APIENTRY glGetSemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
+                                                             GLuint semaphore,
+                                                             GLenum pname,
+                                                             GLuint64 *params)
+{
+    return gl::GetSemaphoreParameterui64vEXTContextANGLE(ctx, semaphore, pname, params);
+}
+
+void GL_APIENTRY glGetShaderInfoLogContextANGLE(GLeglContext ctx,
+                                                GLuint shader,
+                                                GLsizei bufSize,
+                                                GLsizei *length,
+                                                GLchar *infoLog)
+{
+    return gl::GetShaderInfoLogContextANGLE(ctx, shader, bufSize, length, infoLog);
+}
+
+void GL_APIENTRY glGetShaderPrecisionFormatContextANGLE(GLeglContext ctx,
+                                                        GLenum shadertype,
+                                                        GLenum precisiontype,
+                                                        GLint *range,
+                                                        GLint *precision)
+{
+    return gl::GetShaderPrecisionFormatContextANGLE(ctx, shadertype, precisiontype, range,
+                                                    precision);
+}
+
+void GL_APIENTRY glGetShaderSourceContextANGLE(GLeglContext ctx,
+                                               GLuint shader,
+                                               GLsizei bufSize,
+                                               GLsizei *length,
+                                               GLchar *source)
+{
+    return gl::GetShaderSourceContextANGLE(ctx, shader, bufSize, length, source);
+}
+
+void GL_APIENTRY glGetShaderivContextANGLE(GLeglContext ctx,
+                                           GLuint shader,
+                                           GLenum pname,
+                                           GLint *params)
+{
+    return gl::GetShaderivContextANGLE(ctx, shader, pname, params);
+}
+
+const GLubyte *GL_APIENTRY glGetStringContextANGLE(GLeglContext ctx, GLenum name)
+{
+    return gl::GetStringContextANGLE(ctx, name);
+}
+
+const GLubyte *GL_APIENTRY glGetStringiContextANGLE(GLeglContext ctx, GLenum name, GLuint index)
+{
+    return gl::GetStringiContextANGLE(ctx, name, index);
+}
+
+void GL_APIENTRY glGetSyncivContextANGLE(GLeglContext ctx,
+                                         GLsync sync,
+                                         GLenum pname,
+                                         GLsizei bufSize,
+                                         GLsizei *length,
+                                         GLint *values)
+{
+    return gl::GetSyncivContextANGLE(ctx, sync, pname, bufSize, length, values);
+}
+
+void GL_APIENTRY glGetTexEnvfvContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLenum pname,
+                                           GLfloat *params)
+{
+    return gl::GetTexEnvfvContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetTexEnvivContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLenum pname,
+                                           GLint *params)
+{
+    return gl::GetTexEnvivContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetTexEnvxvContextANGLE(GLeglContext ctx,
+                                           GLenum target,
+                                           GLenum pname,
+                                           GLfixed *params)
+{
+    return gl::GetTexEnvxvContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetTexGenfvOESContextANGLE(GLeglContext ctx,
+                                              GLenum coord,
+                                              GLenum pname,
+                                              GLfloat *params)
+{
+    return gl::GetTexGenfvOESContextANGLE(ctx, coord, pname, params);
+}
+
+void GL_APIENTRY glGetTexGenivOESContextANGLE(GLeglContext ctx,
+                                              GLenum coord,
+                                              GLenum pname,
+                                              GLint *params)
+{
+    return gl::GetTexGenivOESContextANGLE(ctx, coord, pname, params);
+}
+
+void GL_APIENTRY glGetTexGenxvOESContextANGLE(GLeglContext ctx,
+                                              GLenum coord,
+                                              GLenum pname,
+                                              GLfixed *params)
+{
+    return gl::GetTexGenxvOESContextANGLE(ctx, coord, pname, params);
+}
+
+void GL_APIENTRY glGetTexLevelParameterfvContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLint level,
+                                                      GLenum pname,
+                                                      GLfloat *params)
+{
+    return gl::GetTexLevelParameterfvContextANGLE(ctx, target, level, pname, params);
+}
+
+void GL_APIENTRY glGetTexLevelParameterivContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLint level,
+                                                      GLenum pname,
+                                                      GLint *params)
+{
+    return gl::GetTexLevelParameterivContextANGLE(ctx, target, level, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameterIivOESContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum pname,
+                                                     GLint *params)
+{
+    return gl::GetTexParameterIivOESContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLenum pname,
+                                                      GLuint *params)
+{
+    return gl::GetTexParameterIuivOESContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameterfvContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLenum pname,
+                                                 GLfloat *params)
+{
+    return gl::GetTexParameterfvContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameterivContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLenum pname,
+                                                 GLint *params)
+{
+    return gl::GetTexParameterivContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetTexParameterxvContextANGLE(GLeglContext ctx,
+                                                 GLenum target,
+                                                 GLenum pname,
+                                                 GLfixed *params)
+{
+    return gl::GetTexParameterxvContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glGetTransformFeedbackVaryingContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLuint index,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLsizei *size,
+                                                           GLenum *type,
+                                                           GLchar *name)
+{
+    return gl::GetTransformFeedbackVaryingContextANGLE(ctx, program, index, bufSize, length, size,
+                                                       type, name);
+}
+
+void GL_APIENTRY glGetTranslatedShaderSourceANGLEContextANGLE(GLeglContext ctx,
+                                                              GLuint shader,
+                                                              GLsizei bufsize,
+                                                              GLsizei *length,
+                                                              GLchar *source)
+{
+    return gl::GetTranslatedShaderSourceANGLEContextANGLE(ctx, shader, bufsize, length, source);
+}
+
+GLuint GL_APIENTRY glGetUniformBlockIndexContextANGLE(GLeglContext ctx,
+                                                      GLuint program,
+                                                      const GLchar *uniformBlockName)
+{
+    return gl::GetUniformBlockIndexContextANGLE(ctx, program, uniformBlockName);
+}
+
+void GL_APIENTRY glGetUniformIndicesContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLsizei uniformCount,
+                                                 const GLchar *const *uniformNames,
+                                                 GLuint *uniformIndices)
+{
+    return gl::GetUniformIndicesContextANGLE(ctx, program, uniformCount, uniformNames,
+                                             uniformIndices);
+}
+
+GLint GL_APIENTRY glGetUniformLocationContextANGLE(GLeglContext ctx,
+                                                   GLuint program,
+                                                   const GLchar *name)
+{
+    return gl::GetUniformLocationContextANGLE(ctx, program, name);
+}
+
+void GL_APIENTRY glGetUniformfvContextANGLE(GLeglContext ctx,
+                                            GLuint program,
+                                            GLint location,
+                                            GLfloat *params)
+{
+    return gl::GetUniformfvContextANGLE(ctx, program, location, params);
+}
+
+void GL_APIENTRY glGetUniformivContextANGLE(GLeglContext ctx,
+                                            GLuint program,
+                                            GLint location,
+                                            GLint *params)
+{
+    return gl::GetUniformivContextANGLE(ctx, program, location, params);
+}
+
+void GL_APIENTRY glGetUniformuivContextANGLE(GLeglContext ctx,
+                                             GLuint program,
+                                             GLint location,
+                                             GLuint *params)
+{
+    return gl::GetUniformuivContextANGLE(ctx, program, location, params);
+}
+
+void GL_APIENTRY glGetUnsignedBytevEXTContextANGLE(GLeglContext ctx, GLenum pname, GLubyte *data)
+{
+    return gl::GetUnsignedBytevEXTContextANGLE(ctx, pname, data);
+}
+
+void GL_APIENTRY glGetUnsignedBytei_vEXTContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLuint index,
+                                                     GLubyte *data)
+{
+    return gl::GetUnsignedBytei_vEXTContextANGLE(ctx, target, index, data);
+}
+
+void GL_APIENTRY glGetVertexAttribIivContextANGLE(GLeglContext ctx,
+                                                  GLuint index,
+                                                  GLenum pname,
+                                                  GLint *params)
+{
+    return gl::GetVertexAttribIivContextANGLE(ctx, index, pname, params);
+}
+
+void GL_APIENTRY glGetVertexAttribIuivContextANGLE(GLeglContext ctx,
+                                                   GLuint index,
+                                                   GLenum pname,
+                                                   GLuint *params)
+{
+    return gl::GetVertexAttribIuivContextANGLE(ctx, index, pname, params);
+}
+
+void GL_APIENTRY glGetVertexAttribPointervContextANGLE(GLeglContext ctx,
+                                                       GLuint index,
+                                                       GLenum pname,
+                                                       void **pointer)
+{
+    return gl::GetVertexAttribPointervContextANGLE(ctx, index, pname, pointer);
+}
+
+void GL_APIENTRY glGetVertexAttribfvContextANGLE(GLeglContext ctx,
+                                                 GLuint index,
+                                                 GLenum pname,
+                                                 GLfloat *params)
+{
+    return gl::GetVertexAttribfvContextANGLE(ctx, index, pname, params);
+}
+
+void GL_APIENTRY glGetVertexAttribivContextANGLE(GLeglContext ctx,
+                                                 GLuint index,
+                                                 GLenum pname,
+                                                 GLint *params)
+{
+    return gl::GetVertexAttribivContextANGLE(ctx, index, pname, params);
+}
+
+void GL_APIENTRY glGetnUniformfvEXTContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLsizei bufSize,
+                                                GLfloat *params)
+{
+    return gl::GetnUniformfvEXTContextANGLE(ctx, program, location, bufSize, params);
+}
+
+void GL_APIENTRY glGetnUniformivEXTContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLsizei bufSize,
+                                                GLint *params)
+{
+    return gl::GetnUniformivEXTContextANGLE(ctx, program, location, bufSize, params);
+}
+
+void GL_APIENTRY glHintContextANGLE(GLeglContext ctx, GLenum target, GLenum mode)
+{
+    return gl::HintContextANGLE(ctx, target, mode);
+}
+
+void GL_APIENTRY glImportMemoryFdEXTContextANGLE(GLeglContext ctx,
+                                                 GLuint memory,
+                                                 GLuint64 size,
+                                                 GLenum handleType,
+                                                 GLint fd)
+{
+    return gl::ImportMemoryFdEXTContextANGLE(ctx, memory, size, handleType, fd);
+}
+
+void GL_APIENTRY glImportSemaphoreFdEXTContextANGLE(GLeglContext ctx,
+                                                    GLuint semaphore,
+                                                    GLenum handleType,
+                                                    GLint fd)
+{
+    return gl::ImportSemaphoreFdEXTContextANGLE(ctx, semaphore, handleType, fd);
+}
+
+void GL_APIENTRY glInsertEventMarkerEXTContextANGLE(GLeglContext ctx,
+                                                    GLsizei length,
+                                                    const GLchar *marker)
+{
+    return gl::InsertEventMarkerEXTContextANGLE(ctx, length, marker);
+}
+
+void GL_APIENTRY glInvalidateFramebufferContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLsizei numAttachments,
+                                                     const GLenum *attachments)
+{
+    return gl::InvalidateFramebufferContextANGLE(ctx, target, numAttachments, attachments);
+}
+
+void GL_APIENTRY glInvalidateSubFramebufferContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLsizei numAttachments,
+                                                        const GLenum *attachments,
+                                                        GLint x,
+                                                        GLint y,
+                                                        GLsizei width,
+                                                        GLsizei height)
+{
+    return gl::InvalidateSubFramebufferContextANGLE(ctx, target, numAttachments, attachments, x, y,
+                                                    width, height);
+}
+
+GLboolean GL_APIENTRY glIsBufferContextANGLE(GLeglContext ctx, GLuint buffer)
+{
+    return gl::IsBufferContextANGLE(ctx, buffer);
+}
+
+GLboolean GL_APIENTRY glIsEnabledContextANGLE(GLeglContext ctx, GLenum cap)
+{
+    return gl::IsEnabledContextANGLE(ctx, cap);
+}
+
+GLboolean GL_APIENTRY glIsFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
+{
+    return gl::IsFenceNVContextANGLE(ctx, fence);
+}
+
+GLboolean GL_APIENTRY glIsFramebufferContextANGLE(GLeglContext ctx, GLuint framebuffer)
+{
+    return gl::IsFramebufferContextANGLE(ctx, framebuffer);
+}
+
+GLboolean GL_APIENTRY glIsFramebufferOESContextANGLE(GLeglContext ctx, GLuint framebuffer)
+{
+    return gl::IsFramebufferOESContextANGLE(ctx, framebuffer);
+}
+
+GLboolean GL_APIENTRY glIsMemoryObjectEXTContextANGLE(GLeglContext ctx, GLuint memoryObject)
+{
+    return gl::IsMemoryObjectEXTContextANGLE(ctx, memoryObject);
+}
+
+GLboolean GL_APIENTRY glIsProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    return gl::IsProgramContextANGLE(ctx, program);
+}
+
+GLboolean GL_APIENTRY glIsProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
+{
+    return gl::IsProgramPipelineContextANGLE(ctx, pipeline);
+}
+
+GLboolean GL_APIENTRY glIsQueryContextANGLE(GLeglContext ctx, GLuint id)
+{
+    return gl::IsQueryContextANGLE(ctx, id);
+}
+
+GLboolean GL_APIENTRY glIsQueryEXTContextANGLE(GLeglContext ctx, GLuint id)
+{
+    return gl::IsQueryEXTContextANGLE(ctx, id);
+}
+
+GLboolean GL_APIENTRY glIsRenderbufferContextANGLE(GLeglContext ctx, GLuint renderbuffer)
+{
+    return gl::IsRenderbufferContextANGLE(ctx, renderbuffer);
+}
+
+GLboolean GL_APIENTRY glIsRenderbufferOESContextANGLE(GLeglContext ctx, GLuint renderbuffer)
+{
+    return gl::IsRenderbufferOESContextANGLE(ctx, renderbuffer);
+}
+
+GLboolean GL_APIENTRY glIsSemaphoreEXTContextANGLE(GLeglContext ctx, GLuint semaphore)
+{
+    return gl::IsSemaphoreEXTContextANGLE(ctx, semaphore);
+}
+
+GLboolean GL_APIENTRY glIsSamplerContextANGLE(GLeglContext ctx, GLuint sampler)
+{
+    return gl::IsSamplerContextANGLE(ctx, sampler);
+}
+
+GLboolean GL_APIENTRY glIsShaderContextANGLE(GLeglContext ctx, GLuint shader)
+{
+    return gl::IsShaderContextANGLE(ctx, shader);
+}
+
+GLboolean GL_APIENTRY glIsSyncContextANGLE(GLeglContext ctx, GLsync sync)
+{
+    return gl::IsSyncContextANGLE(ctx, sync);
+}
+
+GLboolean GL_APIENTRY glIsTextureContextANGLE(GLeglContext ctx, GLuint texture)
+{
+    return gl::IsTextureContextANGLE(ctx, texture);
+}
+
+GLboolean GL_APIENTRY glIsTransformFeedbackContextANGLE(GLeglContext ctx, GLuint id)
+{
+    return gl::IsTransformFeedbackContextANGLE(ctx, id);
+}
+
+GLboolean GL_APIENTRY glIsVertexArrayContextANGLE(GLeglContext ctx, GLuint array)
+{
+    return gl::IsVertexArrayContextANGLE(ctx, array);
+}
+
+GLboolean GL_APIENTRY glIsVertexArrayOESContextANGLE(GLeglContext ctx, GLuint array)
+{
+    return gl::IsVertexArrayOESContextANGLE(ctx, array);
+}
+
+void GL_APIENTRY glLightModelfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
+{
+    return gl::LightModelfContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glLightModelfvContextANGLE(GLeglContext ctx, GLenum pname, const GLfloat *params)
+{
+    return gl::LightModelfvContextANGLE(ctx, pname, params);
+}
+
+void GL_APIENTRY glLightModelxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
+{
+    return gl::LightModelxContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glLightModelxvContextANGLE(GLeglContext ctx, GLenum pname, const GLfixed *param)
+{
+    return gl::LightModelxvContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glLightfContextANGLE(GLeglContext ctx, GLenum light, GLenum pname, GLfloat param)
+{
+    return gl::LightfContextANGLE(ctx, light, pname, param);
+}
+
+void GL_APIENTRY glLightfvContextANGLE(GLeglContext ctx,
+                                       GLenum light,
+                                       GLenum pname,
+                                       const GLfloat *params)
+{
+    return gl::LightfvContextANGLE(ctx, light, pname, params);
+}
+
+void GL_APIENTRY glLightxContextANGLE(GLeglContext ctx, GLenum light, GLenum pname, GLfixed param)
+{
+    return gl::LightxContextANGLE(ctx, light, pname, param);
+}
+
+void GL_APIENTRY glLightxvContextANGLE(GLeglContext ctx,
+                                       GLenum light,
+                                       GLenum pname,
+                                       const GLfixed *params)
+{
+    return gl::LightxvContextANGLE(ctx, light, pname, params);
+}
+
+void GL_APIENTRY glLineWidthContextANGLE(GLeglContext ctx, GLfloat width)
+{
+    return gl::LineWidthContextANGLE(ctx, width);
+}
+
+void GL_APIENTRY glLineWidthxContextANGLE(GLeglContext ctx, GLfixed width)
+{
+    return gl::LineWidthxContextANGLE(ctx, width);
+}
+
+void GL_APIENTRY glLinkProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    return gl::LinkProgramContextANGLE(ctx, program);
+}
+
+void GL_APIENTRY glLoadIdentityContextANGLE(GLeglContext ctx)
+{
+    return gl::LoadIdentityContextANGLE(ctx);
+}
+
+void GL_APIENTRY glLoadMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m)
+{
+    return gl::LoadMatrixfContextANGLE(ctx, m);
+}
+
+void GL_APIENTRY glLoadMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m)
+{
+    return gl::LoadMatrixxContextANGLE(ctx, m);
+}
+
+void GL_APIENTRY glLoadPaletteFromModelViewMatrixOESContextANGLE(GLeglContext ctx)
+{
+    return gl::LoadPaletteFromModelViewMatrixOESContextANGLE(ctx);
+}
+
+void GL_APIENTRY glLogicOpContextANGLE(GLeglContext ctx, GLenum opcode)
+{
+    return gl::LogicOpContextANGLE(ctx, opcode);
+}
+
+void *GL_APIENTRY glMapBufferOESContextANGLE(GLeglContext ctx, GLenum target, GLenum access)
+{
+    return gl::MapBufferOESContextANGLE(ctx, target, access);
+}
+
+void *GL_APIENTRY glMapBufferRangeContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLintptr offset,
+                                               GLsizeiptr length,
+                                               GLbitfield access)
+{
+    return gl::MapBufferRangeContextANGLE(ctx, target, offset, length, access);
+}
+
+void *GL_APIENTRY glMapBufferRangeEXTContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLintptr offset,
+                                                  GLsizeiptr length,
+                                                  GLbitfield access)
+{
+    return gl::MapBufferRangeEXTContextANGLE(ctx, target, offset, length, access);
+}
+
+void GL_APIENTRY glMaterialfContextANGLE(GLeglContext ctx, GLenum face, GLenum pname, GLfloat param)
+{
+    return gl::MaterialfContextANGLE(ctx, face, pname, param);
+}
+
+void GL_APIENTRY glMaterialfvContextANGLE(GLeglContext ctx,
+                                          GLenum face,
+                                          GLenum pname,
+                                          const GLfloat *params)
+{
+    return gl::MaterialfvContextANGLE(ctx, face, pname, params);
+}
+
+void GL_APIENTRY glMaterialxContextANGLE(GLeglContext ctx, GLenum face, GLenum pname, GLfixed param)
+{
+    return gl::MaterialxContextANGLE(ctx, face, pname, param);
+}
+
+void GL_APIENTRY glMaterialxvContextANGLE(GLeglContext ctx,
+                                          GLenum face,
+                                          GLenum pname,
+                                          const GLfixed *param)
+{
+    return gl::MaterialxvContextANGLE(ctx, face, pname, param);
+}
+
+void GL_APIENTRY glMatrixIndexPointerOESContextANGLE(GLeglContext ctx,
+                                                     GLint size,
+                                                     GLenum type,
+                                                     GLsizei stride,
+                                                     const void *pointer)
+{
+    return gl::MatrixIndexPointerOESContextANGLE(ctx, size, type, stride, pointer);
+}
+
+void GL_APIENTRY glMatrixModeContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    return gl::MatrixModeContextANGLE(ctx, mode);
+}
+
+void GL_APIENTRY glMaxShaderCompilerThreadsKHRContextANGLE(GLeglContext ctx, GLuint count)
+{
+    return gl::MaxShaderCompilerThreadsKHRContextANGLE(ctx, count);
+}
+
+void GL_APIENTRY glMemoryBarrierContextANGLE(GLeglContext ctx, GLbitfield barriers)
+{
+    return gl::MemoryBarrierContextANGLE(ctx, barriers);
+}
+
+void GL_APIENTRY glMemoryBarrierByRegionContextANGLE(GLeglContext ctx, GLbitfield barriers)
+{
+    return gl::MemoryBarrierByRegionContextANGLE(ctx, barriers);
+}
+
+void GL_APIENTRY glMemoryObjectParameterivEXTContextANGLE(GLeglContext ctx,
+                                                          GLuint memoryObject,
+                                                          GLenum pname,
+                                                          const GLint *params)
+{
+    return gl::MemoryObjectParameterivEXTContextANGLE(ctx, memoryObject, pname, params);
+}
+
+void GL_APIENTRY glMultMatrixfContextANGLE(GLeglContext ctx, const GLfloat *m)
+{
+    return gl::MultMatrixfContextANGLE(ctx, m);
+}
+
+void GL_APIENTRY glMultMatrixxContextANGLE(GLeglContext ctx, const GLfixed *m)
+{
+    return gl::MultMatrixxContextANGLE(ctx, m);
+}
+
+void GL_APIENTRY glMultiTexCoord4fContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLfloat s,
+                                               GLfloat t,
+                                               GLfloat r,
+                                               GLfloat q)
+{
+    return gl::MultiTexCoord4fContextANGLE(ctx, target, s, t, r, q);
+}
+
+void GL_APIENTRY glMultiTexCoord4xContextANGLE(GLeglContext ctx,
+                                               GLenum texture,
+                                               GLfixed s,
+                                               GLfixed t,
+                                               GLfixed r,
+                                               GLfixed q)
+{
+    return gl::MultiTexCoord4xContextANGLE(ctx, texture, s, t, r, q);
+}
+
+void GL_APIENTRY glNormal3fContextANGLE(GLeglContext ctx, GLfloat nx, GLfloat ny, GLfloat nz)
+{
+    return gl::Normal3fContextANGLE(ctx, nx, ny, nz);
+}
+
+void GL_APIENTRY glNormal3xContextANGLE(GLeglContext ctx, GLfixed nx, GLfixed ny, GLfixed nz)
+{
+    return gl::Normal3xContextANGLE(ctx, nx, ny, nz);
+}
+
+void GL_APIENTRY glNormalPointerContextANGLE(GLeglContext ctx,
+                                             GLenum type,
+                                             GLsizei stride,
+                                             const void *pointer)
+{
+    return gl::NormalPointerContextANGLE(ctx, type, stride, pointer);
+}
+
+void GL_APIENTRY glObjectLabelKHRContextANGLE(GLeglContext ctx,
+                                              GLenum identifier,
+                                              GLuint name,
+                                              GLsizei length,
+                                              const GLchar *label)
+{
+    return gl::ObjectLabelKHRContextANGLE(ctx, identifier, name, length, label);
+}
+
+void GL_APIENTRY glObjectPtrLabelKHRContextANGLE(GLeglContext ctx,
+                                                 const void *ptr,
+                                                 GLsizei length,
+                                                 const GLchar *label)
+{
+    return gl::ObjectPtrLabelKHRContextANGLE(ctx, ptr, length, label);
+}
+
+void GL_APIENTRY glOrthofContextANGLE(GLeglContext ctx,
+                                      GLfloat l,
+                                      GLfloat r,
+                                      GLfloat b,
+                                      GLfloat t,
+                                      GLfloat n,
+                                      GLfloat f)
+{
+    return gl::OrthofContextANGLE(ctx, l, r, b, t, n, f);
+}
+
+void GL_APIENTRY glOrthoxContextANGLE(GLeglContext ctx,
+                                      GLfixed l,
+                                      GLfixed r,
+                                      GLfixed b,
+                                      GLfixed t,
+                                      GLfixed n,
+                                      GLfixed f)
+{
+    return gl::OrthoxContextANGLE(ctx, l, r, b, t, n, f);
+}
+
+void GL_APIENTRY glPauseTransformFeedbackContextANGLE(GLeglContext ctx)
+{
+    return gl::PauseTransformFeedbackContextANGLE(ctx);
+}
+
+void GL_APIENTRY glPixelStoreiContextANGLE(GLeglContext ctx, GLenum pname, GLint param)
+{
+    return gl::PixelStoreiContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glPointParameterfContextANGLE(GLeglContext ctx, GLenum pname, GLfloat param)
+{
+    return gl::PointParameterfContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glPointParameterfvContextANGLE(GLeglContext ctx,
+                                                GLenum pname,
+                                                const GLfloat *params)
+{
+    return gl::PointParameterfvContextANGLE(ctx, pname, params);
+}
+
+void GL_APIENTRY glPointParameterxContextANGLE(GLeglContext ctx, GLenum pname, GLfixed param)
+{
+    return gl::PointParameterxContextANGLE(ctx, pname, param);
+}
+
+void GL_APIENTRY glPointParameterxvContextANGLE(GLeglContext ctx,
+                                                GLenum pname,
+                                                const GLfixed *params)
+{
+    return gl::PointParameterxvContextANGLE(ctx, pname, params);
+}
+
+void GL_APIENTRY glPointSizeContextANGLE(GLeglContext ctx, GLfloat size)
+{
+    return gl::PointSizeContextANGLE(ctx, size);
+}
+
+void GL_APIENTRY glPointSizePointerOESContextANGLE(GLeglContext ctx,
+                                                   GLenum type,
+                                                   GLsizei stride,
+                                                   const void *pointer)
+{
+    return gl::PointSizePointerOESContextANGLE(ctx, type, stride, pointer);
+}
+
+void GL_APIENTRY glPointSizexContextANGLE(GLeglContext ctx, GLfixed size)
+{
+    return gl::PointSizexContextANGLE(ctx, size);
+}
+
+void GL_APIENTRY glPolygonOffsetContextANGLE(GLeglContext ctx, GLfloat factor, GLfloat units)
+{
+    return gl::PolygonOffsetContextANGLE(ctx, factor, units);
+}
+
+void GL_APIENTRY glPolygonOffsetxContextANGLE(GLeglContext ctx, GLfixed factor, GLfixed units)
+{
+    return gl::PolygonOffsetxContextANGLE(ctx, factor, units);
+}
+
+void GL_APIENTRY glPopDebugGroupKHRContextANGLE(GLeglContext ctx)
+{
+    return gl::PopDebugGroupKHRContextANGLE(ctx);
+}
+
+void GL_APIENTRY glPopGroupMarkerEXTContextANGLE(GLeglContext ctx)
+{
+    return gl::PopGroupMarkerEXTContextANGLE(ctx);
+}
+
+void GL_APIENTRY glPopMatrixContextANGLE(GLeglContext ctx)
+{
+    return gl::PopMatrixContextANGLE(ctx);
+}
+
+void GL_APIENTRY glProgramBinaryContextANGLE(GLeglContext ctx,
+                                             GLuint program,
+                                             GLenum binaryFormat,
+                                             const void *binary,
+                                             GLsizei length)
+{
+    return gl::ProgramBinaryContextANGLE(ctx, program, binaryFormat, binary, length);
+}
+
+void GL_APIENTRY glProgramBinaryOESContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLenum binaryFormat,
+                                                const void *binary,
+                                                GLint length)
+{
+    return gl::ProgramBinaryOESContextANGLE(ctx, program, binaryFormat, binary, length);
+}
+
+void GL_APIENTRY glProgramParameteriContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLenum pname,
+                                                 GLint value)
+{
+    return gl::ProgramParameteriContextANGLE(ctx, program, pname, value);
+}
+
+void GL_APIENTRY glProgramUniform1fContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLfloat v0)
+{
+    return gl::ProgramUniform1fContextANGLE(ctx, program, location, v0);
+}
+
+void GL_APIENTRY glProgramUniform1fvContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLfloat *value)
+{
+    return gl::ProgramUniform1fvContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform1iContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLint v0)
+{
+    return gl::ProgramUniform1iContextANGLE(ctx, program, location, v0);
+}
+
+void GL_APIENTRY glProgramUniform1ivContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLint *value)
+{
+    return gl::ProgramUniform1ivContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform1uiContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLuint v0)
+{
+    return gl::ProgramUniform1uiContextANGLE(ctx, program, location, v0);
+}
+
+void GL_APIENTRY glProgramUniform1uivContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  const GLuint *value)
+{
+    return gl::ProgramUniform1uivContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform2fContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLfloat v0,
+                                                GLfloat v1)
+{
+    return gl::ProgramUniform2fContextANGLE(ctx, program, location, v0, v1);
+}
+
+void GL_APIENTRY glProgramUniform2fvContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLfloat *value)
+{
+    return gl::ProgramUniform2fvContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY
+glProgramUniform2iContextANGLE(GLeglContext ctx, GLuint program, GLint location, GLint v0, GLint v1)
+{
+    return gl::ProgramUniform2iContextANGLE(ctx, program, location, v0, v1);
+}
+
+void GL_APIENTRY glProgramUniform2ivContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLint *value)
+{
+    return gl::ProgramUniform2ivContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform2uiContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLuint v0,
+                                                 GLuint v1)
+{
+    return gl::ProgramUniform2uiContextANGLE(ctx, program, location, v0, v1);
+}
+
+void GL_APIENTRY glProgramUniform2uivContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  const GLuint *value)
+{
+    return gl::ProgramUniform2uivContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform3fContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLfloat v0,
+                                                GLfloat v1,
+                                                GLfloat v2)
+{
+    return gl::ProgramUniform3fContextANGLE(ctx, program, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glProgramUniform3fvContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLfloat *value)
+{
+    return gl::ProgramUniform3fvContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform3iContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLint v0,
+                                                GLint v1,
+                                                GLint v2)
+{
+    return gl::ProgramUniform3iContextANGLE(ctx, program, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glProgramUniform3ivContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLint *value)
+{
+    return gl::ProgramUniform3ivContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform3uiContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLuint v0,
+                                                 GLuint v1,
+                                                 GLuint v2)
+{
+    return gl::ProgramUniform3uiContextANGLE(ctx, program, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glProgramUniform3uivContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  const GLuint *value)
+{
+    return gl::ProgramUniform3uivContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform4fContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLfloat v0,
+                                                GLfloat v1,
+                                                GLfloat v2,
+                                                GLfloat v3)
+{
+    return gl::ProgramUniform4fContextANGLE(ctx, program, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glProgramUniform4fvContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLfloat *value)
+{
+    return gl::ProgramUniform4fvContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform4iContextANGLE(GLeglContext ctx,
+                                                GLuint program,
+                                                GLint location,
+                                                GLint v0,
+                                                GLint v1,
+                                                GLint v2,
+                                                GLint v3)
+{
+    return gl::ProgramUniform4iContextANGLE(ctx, program, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glProgramUniform4ivContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLint *value)
+{
+    return gl::ProgramUniform4ivContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniform4uiContextANGLE(GLeglContext ctx,
+                                                 GLuint program,
+                                                 GLint location,
+                                                 GLuint v0,
+                                                 GLuint v1,
+                                                 GLuint v2,
+                                                 GLuint v3)
+{
+    return gl::ProgramUniform4uiContextANGLE(ctx, program, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glProgramUniform4uivContextANGLE(GLeglContext ctx,
+                                                  GLuint program,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  const GLuint *value)
+{
+    return gl::ProgramUniform4uivContextANGLE(ctx, program, location, count, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix2fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix2fvContextANGLE(ctx, program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix2x3fvContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLint location,
+                                                         GLsizei count,
+                                                         GLboolean transpose,
+                                                         const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix2x3fvContextANGLE(ctx, program, location, count, transpose,
+                                                     value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix2x4fvContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLint location,
+                                                         GLsizei count,
+                                                         GLboolean transpose,
+                                                         const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix2x4fvContextANGLE(ctx, program, location, count, transpose,
+                                                     value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix3fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix3fvContextANGLE(ctx, program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix3x2fvContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLint location,
+                                                         GLsizei count,
+                                                         GLboolean transpose,
+                                                         const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix3x2fvContextANGLE(ctx, program, location, count, transpose,
+                                                     value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix3x4fvContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLint location,
+                                                         GLsizei count,
+                                                         GLboolean transpose,
+                                                         const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix3x4fvContextANGLE(ctx, program, location, count, transpose,
+                                                     value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix4fvContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei count,
+                                                       GLboolean transpose,
+                                                       const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix4fvContextANGLE(ctx, program, location, count, transpose, value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix4x2fvContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLint location,
+                                                         GLsizei count,
+                                                         GLboolean transpose,
+                                                         const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix4x2fvContextANGLE(ctx, program, location, count, transpose,
+                                                     value);
+}
+
+void GL_APIENTRY glProgramUniformMatrix4x3fvContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLint location,
+                                                         GLsizei count,
+                                                         GLboolean transpose,
+                                                         const GLfloat *value)
+{
+    return gl::ProgramUniformMatrix4x3fvContextANGLE(ctx, program, location, count, transpose,
+                                                     value);
+}
+
+void GL_APIENTRY glPushDebugGroupKHRContextANGLE(GLeglContext ctx,
+                                                 GLenum source,
+                                                 GLuint id,
+                                                 GLsizei length,
+                                                 const GLchar *message)
+{
+    return gl::PushDebugGroupKHRContextANGLE(ctx, source, id, length, message);
+}
+
+void GL_APIENTRY glPushGroupMarkerEXTContextANGLE(GLeglContext ctx,
+                                                  GLsizei length,
+                                                  const GLchar *marker)
+{
+    return gl::PushGroupMarkerEXTContextANGLE(ctx, length, marker);
+}
+
+void GL_APIENTRY glPushMatrixContextANGLE(GLeglContext ctx)
+{
+    return gl::PushMatrixContextANGLE(ctx);
+}
+
+void GL_APIENTRY glQueryCounterEXTContextANGLE(GLeglContext ctx, GLuint id, GLenum target)
+{
+    return gl::QueryCounterEXTContextANGLE(ctx, id, target);
+}
+
+GLbitfield GL_APIENTRY glQueryMatrixxOESContextANGLE(GLeglContext ctx,
+                                                     GLfixed *mantissa,
+                                                     GLint *exponent)
+{
+    return gl::QueryMatrixxOESContextANGLE(ctx, mantissa, exponent);
+}
+
+void GL_APIENTRY glReadBufferContextANGLE(GLeglContext ctx, GLenum src)
+{
+    return gl::ReadBufferContextANGLE(ctx, src);
+}
+
+void GL_APIENTRY glReadPixelsContextANGLE(GLeglContext ctx,
+                                          GLint x,
+                                          GLint y,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLenum format,
+                                          GLenum type,
+                                          void *pixels)
+{
+    return gl::ReadPixelsContextANGLE(ctx, x, y, width, height, format, type, pixels);
+}
+
+void GL_APIENTRY glReadnPixelsEXTContextANGLE(GLeglContext ctx,
+                                              GLint x,
+                                              GLint y,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLenum format,
+                                              GLenum type,
+                                              GLsizei bufSize,
+                                              void *data)
+{
+    return gl::ReadnPixelsEXTContextANGLE(ctx, x, y, width, height, format, type, bufSize, data);
+}
+
+void GL_APIENTRY glReleaseShaderCompilerContextANGLE(GLeglContext ctx)
+{
+    return gl::ReleaseShaderCompilerContextANGLE(ctx);
+}
+
+void GL_APIENTRY glRenderbufferStorageContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height)
+{
+    return gl::RenderbufferStorageContextANGLE(ctx, target, internalformat, width, height);
+}
+
+void GL_APIENTRY glRenderbufferStorageMultisampleContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLsizei samples,
+                                                              GLenum internalformat,
+                                                              GLsizei width,
+                                                              GLsizei height)
+{
+    return gl::RenderbufferStorageMultisampleContextANGLE(ctx, target, samples, internalformat,
+                                                          width, height);
+}
+
+void GL_APIENTRY glRenderbufferStorageMultisampleANGLEContextANGLE(GLeglContext ctx,
+                                                                   GLenum target,
+                                                                   GLsizei samples,
+                                                                   GLenum internalformat,
+                                                                   GLsizei width,
+                                                                   GLsizei height)
+{
+    return gl::RenderbufferStorageMultisampleANGLEContextANGLE(ctx, target, samples, internalformat,
+                                                               width, height);
+}
+
+void GL_APIENTRY glRenderbufferStorageOESContextANGLE(GLeglContext ctx,
+                                                      GLenum target,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height)
+{
+    return gl::RenderbufferStorageOESContextANGLE(ctx, target, internalformat, width, height);
+}
+
+void GL_APIENTRY glResumeTransformFeedbackContextANGLE(GLeglContext ctx)
+{
+    return gl::ResumeTransformFeedbackContextANGLE(ctx);
+}
+
+void GL_APIENTRY
+glRotatefContextANGLE(GLeglContext ctx, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+{
+    return gl::RotatefContextANGLE(ctx, angle, x, y, z);
+}
+
+void GL_APIENTRY
+glRotatexContextANGLE(GLeglContext ctx, GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
+{
+    return gl::RotatexContextANGLE(ctx, angle, x, y, z);
+}
+
+void GL_APIENTRY glSampleCoverageContextANGLE(GLeglContext ctx, GLfloat value, GLboolean invert)
+{
+    return gl::SampleCoverageContextANGLE(ctx, value, invert);
+}
+
+void GL_APIENTRY glSampleCoveragexContextANGLE(GLeglContext ctx, GLclampx value, GLboolean invert)
+{
+    return gl::SampleCoveragexContextANGLE(ctx, value, invert);
+}
+
+void GL_APIENTRY glSampleMaskiContextANGLE(GLeglContext ctx, GLuint maskNumber, GLbitfield mask)
+{
+    return gl::SampleMaskiContextANGLE(ctx, maskNumber, mask);
+}
+
+void GL_APIENTRY glSamplerParameterIivOESContextANGLE(GLeglContext ctx,
+                                                      GLuint sampler,
+                                                      GLenum pname,
+                                                      const GLint *param)
+{
+    return gl::SamplerParameterIivOESContextANGLE(ctx, sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                       GLuint sampler,
+                                                       GLenum pname,
+                                                       const GLuint *param)
+{
+    return gl::SamplerParameterIuivOESContextANGLE(ctx, sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameterfContextANGLE(GLeglContext ctx,
+                                                 GLuint sampler,
+                                                 GLenum pname,
+                                                 GLfloat param)
+{
+    return gl::SamplerParameterfContextANGLE(ctx, sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameterfvContextANGLE(GLeglContext ctx,
+                                                  GLuint sampler,
+                                                  GLenum pname,
+                                                  const GLfloat *param)
+{
+    return gl::SamplerParameterfvContextANGLE(ctx, sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameteriContextANGLE(GLeglContext ctx,
+                                                 GLuint sampler,
+                                                 GLenum pname,
+                                                 GLint param)
+{
+    return gl::SamplerParameteriContextANGLE(ctx, sampler, pname, param);
+}
+
+void GL_APIENTRY glSamplerParameterivContextANGLE(GLeglContext ctx,
+                                                  GLuint sampler,
+                                                  GLenum pname,
+                                                  const GLint *param)
+{
+    return gl::SamplerParameterivContextANGLE(ctx, sampler, pname, param);
+}
+
+void GL_APIENTRY glScalefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z)
+{
+    return gl::ScalefContextANGLE(ctx, x, y, z);
+}
+
+void GL_APIENTRY glScalexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z)
+{
+    return gl::ScalexContextANGLE(ctx, x, y, z);
+}
+
+void GL_APIENTRY
+glScissorContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    return gl::ScissorContextANGLE(ctx, x, y, width, height);
+}
+
+void GL_APIENTRY glSemaphoreParameterui64vEXTContextANGLE(GLeglContext ctx,
+                                                          GLuint semaphore,
+                                                          GLenum pname,
+                                                          const GLuint64 *params)
+{
+    return gl::SemaphoreParameterui64vEXTContextANGLE(ctx, semaphore, pname, params);
+}
+
+void GL_APIENTRY glSetFenceNVContextANGLE(GLeglContext ctx, GLuint fence, GLenum condition)
+{
+    return gl::SetFenceNVContextANGLE(ctx, fence, condition);
+}
+
+void GL_APIENTRY glShadeModelContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    return gl::ShadeModelContextANGLE(ctx, mode);
+}
+
+void GL_APIENTRY glShaderBinaryContextANGLE(GLeglContext ctx,
+                                            GLsizei count,
+                                            const GLuint *shaders,
+                                            GLenum binaryformat,
+                                            const void *binary,
+                                            GLsizei length)
+{
+    return gl::ShaderBinaryContextANGLE(ctx, count, shaders, binaryformat, binary, length);
+}
+
+void GL_APIENTRY glShaderSourceContextANGLE(GLeglContext ctx,
+                                            GLuint shader,
+                                            GLsizei count,
+                                            const GLchar *const *string,
+                                            const GLint *length)
+{
+    return gl::ShaderSourceContextANGLE(ctx, shader, count, string, length);
+}
+
+void GL_APIENTRY glSignalSemaphoreEXTContextANGLE(GLeglContext ctx,
+                                                  GLuint semaphore,
+                                                  GLuint numBufferBarriers,
+                                                  const GLuint *buffers,
+                                                  GLuint numTextureBarriers,
+                                                  const GLuint *textures,
+                                                  const GLenum *dstLayouts)
+{
+    return gl::SignalSemaphoreEXTContextANGLE(ctx, semaphore, numBufferBarriers, buffers,
+                                              numTextureBarriers, textures, dstLayouts);
+}
+
+void GL_APIENTRY glStencilFuncContextANGLE(GLeglContext ctx, GLenum func, GLint ref, GLuint mask)
+{
+    return gl::StencilFuncContextANGLE(ctx, func, ref, mask);
+}
+
+void GL_APIENTRY glStencilFuncSeparateContextANGLE(GLeglContext ctx,
+                                                   GLenum face,
+                                                   GLenum func,
+                                                   GLint ref,
+                                                   GLuint mask)
+{
+    return gl::StencilFuncSeparateContextANGLE(ctx, face, func, ref, mask);
+}
+
+void GL_APIENTRY glStencilMaskContextANGLE(GLeglContext ctx, GLuint mask)
+{
+    return gl::StencilMaskContextANGLE(ctx, mask);
+}
+
+void GL_APIENTRY glStencilMaskSeparateContextANGLE(GLeglContext ctx, GLenum face, GLuint mask)
+{
+    return gl::StencilMaskSeparateContextANGLE(ctx, face, mask);
+}
+
+void GL_APIENTRY glStencilOpContextANGLE(GLeglContext ctx, GLenum fail, GLenum zfail, GLenum zpass)
+{
+    return gl::StencilOpContextANGLE(ctx, fail, zfail, zpass);
+}
+
+void GL_APIENTRY glStencilOpSeparateContextANGLE(GLeglContext ctx,
+                                                 GLenum face,
+                                                 GLenum sfail,
+                                                 GLenum dpfail,
+                                                 GLenum dppass)
+{
+    return gl::StencilOpSeparateContextANGLE(ctx, face, sfail, dpfail, dppass);
+}
+
+GLboolean GL_APIENTRY glTestFenceNVContextANGLE(GLeglContext ctx, GLuint fence)
+{
+    return gl::TestFenceNVContextANGLE(ctx, fence);
+}
+
+void GL_APIENTRY glTexCoordPointerContextANGLE(GLeglContext ctx,
+                                               GLint size,
+                                               GLenum type,
+                                               GLsizei stride,
+                                               const void *pointer)
+{
+    return gl::TexCoordPointerContextANGLE(ctx, size, type, stride, pointer);
+}
+
+void GL_APIENTRY glTexEnvfContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLfloat param)
+{
+    return gl::TexEnvfContextANGLE(ctx, target, pname, param);
+}
+
+void GL_APIENTRY glTexEnvfvContextANGLE(GLeglContext ctx,
+                                        GLenum target,
+                                        GLenum pname,
+                                        const GLfloat *params)
+{
+    return gl::TexEnvfvContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glTexEnviContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLint param)
+{
+    return gl::TexEnviContextANGLE(ctx, target, pname, param);
+}
+
+void GL_APIENTRY glTexEnvivContextANGLE(GLeglContext ctx,
+                                        GLenum target,
+                                        GLenum pname,
+                                        const GLint *params)
+{
+    return gl::TexEnvivContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glTexEnvxContextANGLE(GLeglContext ctx, GLenum target, GLenum pname, GLfixed param)
+{
+    return gl::TexEnvxContextANGLE(ctx, target, pname, param);
+}
+
+void GL_APIENTRY glTexEnvxvContextANGLE(GLeglContext ctx,
+                                        GLenum target,
+                                        GLenum pname,
+                                        const GLfixed *params)
+{
+    return gl::TexEnvxvContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glTexGenfOESContextANGLE(GLeglContext ctx,
+                                          GLenum coord,
+                                          GLenum pname,
+                                          GLfloat param)
+{
+    return gl::TexGenfOESContextANGLE(ctx, coord, pname, param);
+}
+
+void GL_APIENTRY glTexGenfvOESContextANGLE(GLeglContext ctx,
+                                           GLenum coord,
+                                           GLenum pname,
+                                           const GLfloat *params)
+{
+    return gl::TexGenfvOESContextANGLE(ctx, coord, pname, params);
+}
+
+void GL_APIENTRY glTexGeniOESContextANGLE(GLeglContext ctx, GLenum coord, GLenum pname, GLint param)
+{
+    return gl::TexGeniOESContextANGLE(ctx, coord, pname, param);
+}
+
+void GL_APIENTRY glTexGenivOESContextANGLE(GLeglContext ctx,
+                                           GLenum coord,
+                                           GLenum pname,
+                                           const GLint *params)
+{
+    return gl::TexGenivOESContextANGLE(ctx, coord, pname, params);
+}
+
+void GL_APIENTRY glTexGenxOESContextANGLE(GLeglContext ctx,
+                                          GLenum coord,
+                                          GLenum pname,
+                                          GLfixed param)
+{
+    return gl::TexGenxOESContextANGLE(ctx, coord, pname, param);
+}
+
+void GL_APIENTRY glTexGenxvOESContextANGLE(GLeglContext ctx,
+                                           GLenum coord,
+                                           GLenum pname,
+                                           const GLfixed *params)
+{
+    return gl::TexGenxvOESContextANGLE(ctx, coord, pname, params);
+}
+
+void GL_APIENTRY glTexImage2DContextANGLE(GLeglContext ctx,
+                                          GLenum target,
+                                          GLint level,
+                                          GLint internalformat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLint border,
+                                          GLenum format,
+                                          GLenum type,
+                                          const void *pixels)
+{
+    return gl::TexImage2DContextANGLE(ctx, target, level, internalformat, width, height, border,
+                                      format, type, pixels);
+}
+
+void GL_APIENTRY glTexImage3DContextANGLE(GLeglContext ctx,
+                                          GLenum target,
+                                          GLint level,
+                                          GLint internalformat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLsizei depth,
+                                          GLint border,
+                                          GLenum format,
+                                          GLenum type,
+                                          const void *pixels)
+{
+    return gl::TexImage3DContextANGLE(ctx, target, level, internalformat, width, height, depth,
+                                      border, format, type, pixels);
+}
+
+void GL_APIENTRY glTexImage3DOESContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLint level,
+                                             GLenum internalformat,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLsizei depth,
+                                             GLint border,
+                                             GLenum format,
+                                             GLenum type,
+                                             const void *pixels)
+{
+    return gl::TexImage3DOESContextANGLE(ctx, target, level, internalformat, width, height, depth,
+                                         border, format, type, pixels);
+}
+
+void GL_APIENTRY glTexParameterIivOESContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLenum pname,
+                                                  const GLint *params)
+{
+    return gl::TexParameterIivOESContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glTexParameterIuivOESContextANGLE(GLeglContext ctx,
+                                                   GLenum target,
+                                                   GLenum pname,
+                                                   const GLuint *params)
+{
+    return gl::TexParameterIuivOESContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glTexParameterfContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLenum pname,
+                                             GLfloat param)
+{
+    return gl::TexParameterfContextANGLE(ctx, target, pname, param);
+}
+
+void GL_APIENTRY glTexParameterfvContextANGLE(GLeglContext ctx,
+                                              GLenum target,
+                                              GLenum pname,
+                                              const GLfloat *params)
+{
+    return gl::TexParameterfvContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glTexParameteriContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLenum pname,
+                                             GLint param)
+{
+    return gl::TexParameteriContextANGLE(ctx, target, pname, param);
+}
+
+void GL_APIENTRY glTexParameterivContextANGLE(GLeglContext ctx,
+                                              GLenum target,
+                                              GLenum pname,
+                                              const GLint *params)
+{
+    return gl::TexParameterivContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glTexParameterxContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLenum pname,
+                                             GLfixed param)
+{
+    return gl::TexParameterxContextANGLE(ctx, target, pname, param);
+}
+
+void GL_APIENTRY glTexParameterxvContextANGLE(GLeglContext ctx,
+                                              GLenum target,
+                                              GLenum pname,
+                                              const GLfixed *params)
+{
+    return gl::TexParameterxvContextANGLE(ctx, target, pname, params);
+}
+
+void GL_APIENTRY glTexStorage1DEXTContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLsizei levels,
+                                               GLenum internalformat,
+                                               GLsizei width)
+{
+    return gl::TexStorage1DEXTContextANGLE(ctx, target, levels, internalformat, width);
+}
+
+void GL_APIENTRY glTexStorage2DContextANGLE(GLeglContext ctx,
+                                            GLenum target,
+                                            GLsizei levels,
+                                            GLenum internalformat,
+                                            GLsizei width,
+                                            GLsizei height)
+{
+    return gl::TexStorage2DContextANGLE(ctx, target, levels, internalformat, width, height);
+}
+
+void GL_APIENTRY glTexStorage2DEXTContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLsizei levels,
+                                               GLenum internalformat,
+                                               GLsizei width,
+                                               GLsizei height)
+{
+    return gl::TexStorage2DEXTContextANGLE(ctx, target, levels, internalformat, width, height);
+}
+
+void GL_APIENTRY glTexStorage2DMultisampleContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLsizei samples,
+                                                       GLenum internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLboolean fixedsamplelocations)
+{
+    return gl::TexStorage2DMultisampleContextANGLE(ctx, target, samples, internalformat, width,
+                                                   height, fixedsamplelocations);
+}
+
+void GL_APIENTRY glTexStorage3DContextANGLE(GLeglContext ctx,
+                                            GLenum target,
+                                            GLsizei levels,
+                                            GLenum internalformat,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth)
+{
+    return gl::TexStorage3DContextANGLE(ctx, target, levels, internalformat, width, height, depth);
+}
+
+void GL_APIENTRY glTexStorage3DEXTContextANGLE(GLeglContext ctx,
+                                               GLenum target,
+                                               GLsizei levels,
+                                               GLenum internalformat,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLsizei depth)
+{
+    return gl::TexStorage3DEXTContextANGLE(ctx, target, levels, internalformat, width, height,
+                                           depth);
+}
+
+void GL_APIENTRY glTexStorage3DMultisampleOESContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLsizei samples,
+                                                          GLenum internalformat,
+                                                          GLsizei width,
+                                                          GLsizei height,
+                                                          GLsizei depth,
+                                                          GLboolean fixedsamplelocations)
+{
+    return gl::TexStorage3DMultisampleOESContextANGLE(ctx, target, samples, internalformat, width,
+                                                      height, depth, fixedsamplelocations);
+}
+
+void GL_APIENTRY glTexStorageMem2DEXTContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLsizei levels,
+                                                  GLenum internalFormat,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLuint memory,
+                                                  GLuint64 offset)
+{
+    return gl::TexStorageMem2DEXTContextANGLE(ctx, target, levels, internalFormat, width, height,
+                                              memory, offset);
+}
+
+void GL_APIENTRY glTexStorageMem2DMultisampleEXTContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLsizei samples,
+                                                             GLenum internalFormat,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             GLboolean fixedSampleLocations,
+                                                             GLuint memory,
+                                                             GLuint64 offset)
+{
+    return gl::TexStorageMem2DMultisampleEXTContextANGLE(
+        ctx, target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
+}
+
+void GL_APIENTRY glTexStorageMem3DEXTContextANGLE(GLeglContext ctx,
+                                                  GLenum target,
+                                                  GLsizei levels,
+                                                  GLenum internalFormat,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLsizei depth,
+                                                  GLuint memory,
+                                                  GLuint64 offset)
+{
+    return gl::TexStorageMem3DEXTContextANGLE(ctx, target, levels, internalFormat, width, height,
+                                              depth, memory, offset);
+}
+
+void GL_APIENTRY glTexStorageMem3DMultisampleEXTContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLsizei samples,
+                                                             GLenum internalFormat,
+                                                             GLsizei width,
+                                                             GLsizei height,
+                                                             GLsizei depth,
+                                                             GLboolean fixedSampleLocations,
+                                                             GLuint memory,
+                                                             GLuint64 offset)
+{
+    return gl::TexStorageMem3DMultisampleEXTContextANGLE(ctx, target, samples, internalFormat,
+                                                         width, height, depth, fixedSampleLocations,
+                                                         memory, offset);
+}
+
+void GL_APIENTRY glTexSubImage2DContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLint yoffset,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLenum format,
+                                             GLenum type,
+                                             const void *pixels)
+{
+    return gl::TexSubImage2DContextANGLE(ctx, target, level, xoffset, yoffset, width, height,
+                                         format, type, pixels);
+}
+
+void GL_APIENTRY glTexSubImage3DContextANGLE(GLeglContext ctx,
+                                             GLenum target,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLint yoffset,
+                                             GLint zoffset,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLsizei depth,
+                                             GLenum format,
+                                             GLenum type,
+                                             const void *pixels)
+{
+    return gl::TexSubImage3DContextANGLE(ctx, target, level, xoffset, yoffset, zoffset, width,
+                                         height, depth, format, type, pixels);
+}
+
+void GL_APIENTRY glTexSubImage3DOESContextANGLE(GLeglContext ctx,
+                                                GLenum target,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint zoffset,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLsizei depth,
+                                                GLenum format,
+                                                GLenum type,
+                                                const void *pixels)
+{
+    return gl::TexSubImage3DOESContextANGLE(ctx, target, level, xoffset, yoffset, zoffset, width,
+                                            height, depth, format, type, pixels);
+}
+
+void GL_APIENTRY glTransformFeedbackVaryingsContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLsizei count,
+                                                         const GLchar *const *varyings,
+                                                         GLenum bufferMode)
+{
+    return gl::TransformFeedbackVaryingsContextANGLE(ctx, program, count, varyings, bufferMode);
+}
+
+void GL_APIENTRY glTranslatefContextANGLE(GLeglContext ctx, GLfloat x, GLfloat y, GLfloat z)
+{
+    return gl::TranslatefContextANGLE(ctx, x, y, z);
+}
+
+void GL_APIENTRY glTranslatexContextANGLE(GLeglContext ctx, GLfixed x, GLfixed y, GLfixed z)
+{
+    return gl::TranslatexContextANGLE(ctx, x, y, z);
+}
+
+void GL_APIENTRY glUniform1fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0)
+{
+    return gl::Uniform1fContextANGLE(ctx, location, v0);
+}
+
+void GL_APIENTRY glUniform1fvContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLsizei count,
+                                          const GLfloat *value)
+{
+    return gl::Uniform1fvContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY glUniform1iContextANGLE(GLeglContext ctx, GLint location, GLint v0)
+{
+    return gl::Uniform1iContextANGLE(ctx, location, v0);
+}
+
+void GL_APIENTRY glUniform1ivContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLsizei count,
+                                          const GLint *value)
+{
+    return gl::Uniform1ivContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY glUniform1uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0)
+{
+    return gl::Uniform1uiContextANGLE(ctx, location, v0);
+}
+
+void GL_APIENTRY glUniform1uivContextANGLE(GLeglContext ctx,
+                                           GLint location,
+                                           GLsizei count,
+                                           const GLuint *value)
+{
+    return gl::Uniform1uivContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY glUniform2fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1)
+{
+    return gl::Uniform2fContextANGLE(ctx, location, v0, v1);
+}
+
+void GL_APIENTRY glUniform2fvContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLsizei count,
+                                          const GLfloat *value)
+{
+    return gl::Uniform2fvContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY glUniform2iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1)
+{
+    return gl::Uniform2iContextANGLE(ctx, location, v0, v1);
+}
+
+void GL_APIENTRY glUniform2ivContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLsizei count,
+                                          const GLint *value)
+{
+    return gl::Uniform2ivContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY glUniform2uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1)
+{
+    return gl::Uniform2uiContextANGLE(ctx, location, v0, v1);
+}
+
+void GL_APIENTRY glUniform2uivContextANGLE(GLeglContext ctx,
+                                           GLint location,
+                                           GLsizei count,
+                                           const GLuint *value)
+{
+    return gl::Uniform2uivContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY
+glUniform3fContextANGLE(GLeglContext ctx, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+{
+    return gl::Uniform3fContextANGLE(ctx, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glUniform3fvContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLsizei count,
+                                          const GLfloat *value)
+{
+    return gl::Uniform3fvContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY
+glUniform3iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2)
+{
+    return gl::Uniform3iContextANGLE(ctx, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glUniform3ivContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLsizei count,
+                                          const GLint *value)
+{
+    return gl::Uniform3ivContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY
+glUniform3uiContextANGLE(GLeglContext ctx, GLint location, GLuint v0, GLuint v1, GLuint v2)
+{
+    return gl::Uniform3uiContextANGLE(ctx, location, v0, v1, v2);
+}
+
+void GL_APIENTRY glUniform3uivContextANGLE(GLeglContext ctx,
+                                           GLint location,
+                                           GLsizei count,
+                                           const GLuint *value)
+{
+    return gl::Uniform3uivContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY glUniform4fContextANGLE(GLeglContext ctx,
+                                         GLint location,
+                                         GLfloat v0,
+                                         GLfloat v1,
+                                         GLfloat v2,
+                                         GLfloat v3)
+{
+    return gl::Uniform4fContextANGLE(ctx, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glUniform4fvContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLsizei count,
+                                          const GLfloat *value)
+{
+    return gl::Uniform4fvContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY
+glUniform4iContextANGLE(GLeglContext ctx, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+{
+    return gl::Uniform4iContextANGLE(ctx, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glUniform4ivContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLsizei count,
+                                          const GLint *value)
+{
+    return gl::Uniform4ivContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY glUniform4uiContextANGLE(GLeglContext ctx,
+                                          GLint location,
+                                          GLuint v0,
+                                          GLuint v1,
+                                          GLuint v2,
+                                          GLuint v3)
+{
+    return gl::Uniform4uiContextANGLE(ctx, location, v0, v1, v2, v3);
+}
+
+void GL_APIENTRY glUniform4uivContextANGLE(GLeglContext ctx,
+                                           GLint location,
+                                           GLsizei count,
+                                           const GLuint *value)
+{
+    return gl::Uniform4uivContextANGLE(ctx, location, count, value);
+}
+
+void GL_APIENTRY glUniformBlockBindingContextANGLE(GLeglContext ctx,
+                                                   GLuint program,
+                                                   GLuint uniformBlockIndex,
+                                                   GLuint uniformBlockBinding)
+{
+    return gl::UniformBlockBindingContextANGLE(ctx, program, uniformBlockIndex,
+                                               uniformBlockBinding);
+}
+
+void GL_APIENTRY glUniformMatrix2fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    return gl::UniformMatrix2fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix2x3fvContextANGLE(GLeglContext ctx,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value)
+{
+    return gl::UniformMatrix2x3fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix2x4fvContextANGLE(GLeglContext ctx,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value)
+{
+    return gl::UniformMatrix2x4fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix3fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    return gl::UniformMatrix3fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix3x2fvContextANGLE(GLeglContext ctx,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value)
+{
+    return gl::UniformMatrix3x2fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix3x4fvContextANGLE(GLeglContext ctx,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value)
+{
+    return gl::UniformMatrix3x4fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix4fvContextANGLE(GLeglContext ctx,
+                                                GLint location,
+                                                GLsizei count,
+                                                GLboolean transpose,
+                                                const GLfloat *value)
+{
+    return gl::UniformMatrix4fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix4x2fvContextANGLE(GLeglContext ctx,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value)
+{
+    return gl::UniformMatrix4x2fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+void GL_APIENTRY glUniformMatrix4x3fvContextANGLE(GLeglContext ctx,
+                                                  GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat *value)
+{
+    return gl::UniformMatrix4x3fvContextANGLE(ctx, location, count, transpose, value);
+}
+
+GLboolean GL_APIENTRY glUnmapBufferContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::UnmapBufferContextANGLE(ctx, target);
+}
+
+GLboolean GL_APIENTRY glUnmapBufferOESContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::UnmapBufferOESContextANGLE(ctx, target);
+}
+
+void GL_APIENTRY glUseProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    return gl::UseProgramContextANGLE(ctx, program);
+}
+
+void GL_APIENTRY glUseProgramStagesContextANGLE(GLeglContext ctx,
+                                                GLuint pipeline,
+                                                GLbitfield stages,
+                                                GLuint program)
+{
+    return gl::UseProgramStagesContextANGLE(ctx, pipeline, stages, program);
+}
+
+void GL_APIENTRY glValidateProgramContextANGLE(GLeglContext ctx, GLuint program)
+{
+    return gl::ValidateProgramContextANGLE(ctx, program);
+}
+
+void GL_APIENTRY glValidateProgramPipelineContextANGLE(GLeglContext ctx, GLuint pipeline)
+{
+    return gl::ValidateProgramPipelineContextANGLE(ctx, pipeline);
+}
+
+void GL_APIENTRY glVertexAttrib1fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x)
+{
+    return gl::VertexAttrib1fContextANGLE(ctx, index, x);
+}
+
+void GL_APIENTRY glVertexAttrib1fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
+{
+    return gl::VertexAttrib1fvContextANGLE(ctx, index, v);
+}
+
+void GL_APIENTRY glVertexAttrib2fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y)
+{
+    return gl::VertexAttrib2fContextANGLE(ctx, index, x, y);
+}
+
+void GL_APIENTRY glVertexAttrib2fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
+{
+    return gl::VertexAttrib2fvContextANGLE(ctx, index, v);
+}
+
+void GL_APIENTRY
+glVertexAttrib3fContextANGLE(GLeglContext ctx, GLuint index, GLfloat x, GLfloat y, GLfloat z)
+{
+    return gl::VertexAttrib3fContextANGLE(ctx, index, x, y, z);
+}
+
+void GL_APIENTRY glVertexAttrib3fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
+{
+    return gl::VertexAttrib3fvContextANGLE(ctx, index, v);
+}
+
+void GL_APIENTRY glVertexAttrib4fContextANGLE(GLeglContext ctx,
+                                              GLuint index,
+                                              GLfloat x,
+                                              GLfloat y,
+                                              GLfloat z,
+                                              GLfloat w)
+{
+    return gl::VertexAttrib4fContextANGLE(ctx, index, x, y, z, w);
+}
+
+void GL_APIENTRY glVertexAttrib4fvContextANGLE(GLeglContext ctx, GLuint index, const GLfloat *v)
+{
+    return gl::VertexAttrib4fvContextANGLE(ctx, index, v);
+}
+
+void GL_APIENTRY glVertexAttribBindingContextANGLE(GLeglContext ctx,
+                                                   GLuint attribindex,
+                                                   GLuint bindingindex)
+{
+    return gl::VertexAttribBindingContextANGLE(ctx, attribindex, bindingindex);
+}
+
+void GL_APIENTRY glVertexAttribDivisorContextANGLE(GLeglContext ctx, GLuint index, GLuint divisor)
+{
+    return gl::VertexAttribDivisorContextANGLE(ctx, index, divisor);
+}
+
+void GL_APIENTRY glVertexAttribDivisorANGLEContextANGLE(GLeglContext ctx,
+                                                        GLuint index,
+                                                        GLuint divisor)
+{
+    return gl::VertexAttribDivisorANGLEContextANGLE(ctx, index, divisor);
+}
+
+void GL_APIENTRY glVertexAttribDivisorEXTContextANGLE(GLeglContext ctx,
+                                                      GLuint index,
+                                                      GLuint divisor)
+{
+    return gl::VertexAttribDivisorEXTContextANGLE(ctx, index, divisor);
+}
+
+void GL_APIENTRY glVertexAttribFormatContextANGLE(GLeglContext ctx,
+                                                  GLuint attribindex,
+                                                  GLint size,
+                                                  GLenum type,
+                                                  GLboolean normalized,
+                                                  GLuint relativeoffset)
+{
+    return gl::VertexAttribFormatContextANGLE(ctx, attribindex, size, type, normalized,
+                                              relativeoffset);
+}
+
+void GL_APIENTRY
+glVertexAttribI4iContextANGLE(GLeglContext ctx, GLuint index, GLint x, GLint y, GLint z, GLint w)
+{
+    return gl::VertexAttribI4iContextANGLE(ctx, index, x, y, z, w);
+}
+
+void GL_APIENTRY glVertexAttribI4ivContextANGLE(GLeglContext ctx, GLuint index, const GLint *v)
+{
+    return gl::VertexAttribI4ivContextANGLE(ctx, index, v);
+}
+
+void GL_APIENTRY glVertexAttribI4uiContextANGLE(GLeglContext ctx,
+                                                GLuint index,
+                                                GLuint x,
+                                                GLuint y,
+                                                GLuint z,
+                                                GLuint w)
+{
+    return gl::VertexAttribI4uiContextANGLE(ctx, index, x, y, z, w);
+}
+
+void GL_APIENTRY glVertexAttribI4uivContextANGLE(GLeglContext ctx, GLuint index, const GLuint *v)
+{
+    return gl::VertexAttribI4uivContextANGLE(ctx, index, v);
+}
+
+void GL_APIENTRY glVertexAttribIFormatContextANGLE(GLeglContext ctx,
+                                                   GLuint attribindex,
+                                                   GLint size,
+                                                   GLenum type,
+                                                   GLuint relativeoffset)
+{
+    return gl::VertexAttribIFormatContextANGLE(ctx, attribindex, size, type, relativeoffset);
+}
+
+void GL_APIENTRY glVertexAttribIPointerContextANGLE(GLeglContext ctx,
+                                                    GLuint index,
+                                                    GLint size,
+                                                    GLenum type,
+                                                    GLsizei stride,
+                                                    const void *pointer)
+{
+    return gl::VertexAttribIPointerContextANGLE(ctx, index, size, type, stride, pointer);
+}
+
+void GL_APIENTRY glVertexAttribPointerContextANGLE(GLeglContext ctx,
+                                                   GLuint index,
+                                                   GLint size,
+                                                   GLenum type,
+                                                   GLboolean normalized,
+                                                   GLsizei stride,
+                                                   const void *pointer)
+{
+    return gl::VertexAttribPointerContextANGLE(ctx, index, size, type, normalized, stride, pointer);
+}
+
+void GL_APIENTRY glVertexBindingDivisorContextANGLE(GLeglContext ctx,
+                                                    GLuint bindingindex,
+                                                    GLuint divisor)
+{
+    return gl::VertexBindingDivisorContextANGLE(ctx, bindingindex, divisor);
+}
+
+void GL_APIENTRY glVertexPointerContextANGLE(GLeglContext ctx,
+                                             GLint size,
+                                             GLenum type,
+                                             GLsizei stride,
+                                             const void *pointer)
+{
+    return gl::VertexPointerContextANGLE(ctx, size, type, stride, pointer);
+}
+
+void GL_APIENTRY
+glViewportContextANGLE(GLeglContext ctx, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+    return gl::ViewportContextANGLE(ctx, x, y, width, height);
+}
+
+void GL_APIENTRY glWaitSemaphoreEXTContextANGLE(GLeglContext ctx,
+                                                GLuint semaphore,
+                                                GLuint numBufferBarriers,
+                                                const GLuint *buffers,
+                                                GLuint numTextureBarriers,
+                                                const GLuint *textures,
+                                                const GLenum *srcLayouts)
+{
+    return gl::WaitSemaphoreEXTContextANGLE(ctx, semaphore, numBufferBarriers, buffers,
+                                            numTextureBarriers, textures, srcLayouts);
+}
+
+void GL_APIENTRY glWaitSyncContextANGLE(GLeglContext ctx,
+                                        GLsync sync,
+                                        GLbitfield flags,
+                                        GLuint64 timeout)
+{
+    return gl::WaitSyncContextANGLE(ctx, sync, flags, timeout);
+}
+
+void GL_APIENTRY glWeightPointerOESContextANGLE(GLeglContext ctx,
+                                                GLint size,
+                                                GLenum type,
+                                                GLsizei stride,
+                                                const void *pointer)
+{
+    return gl::WeightPointerOESContextANGLE(ctx, size, type, stride, pointer);
+}
+
+void GL_APIENTRY glBindUniformLocationCHROMIUMContextANGLE(GLeglContext ctx,
+                                                           GLuint program,
+                                                           GLint location,
+                                                           const GLchar *name)
+{
+    return gl::BindUniformLocationCHROMIUMContextANGLE(ctx, program, location, name);
+}
+
+void GL_APIENTRY glCoverageModulationCHROMIUMContextANGLE(GLeglContext ctx, GLenum components)
+{
+    return gl::CoverageModulationCHROMIUMContextANGLE(ctx, components);
+}
+
+void GL_APIENTRY glMatrixLoadfCHROMIUMContextANGLE(GLeglContext ctx,
+                                                   GLenum matrixMode,
+                                                   const GLfloat *matrix)
+{
+    return gl::MatrixLoadfCHROMIUMContextANGLE(ctx, matrixMode, matrix);
+}
+
+void GL_APIENTRY glMatrixLoadIdentityCHROMIUMContextANGLE(GLeglContext ctx, GLenum matrixMode)
+{
+    return gl::MatrixLoadIdentityCHROMIUMContextANGLE(ctx, matrixMode);
+}
+
+GLuint GL_APIENTRY glGenPathsCHROMIUMContextANGLE(GLeglContext ctx, GLsizei range)
+{
+    return gl::GenPathsCHROMIUMContextANGLE(ctx, range);
+}
+
+void GL_APIENTRY glDeletePathsCHROMIUMContextANGLE(GLeglContext ctx, GLuint first, GLsizei range)
+{
+    return gl::DeletePathsCHROMIUMContextANGLE(ctx, first, range);
+}
+
+GLboolean GL_APIENTRY glIsPathCHROMIUMContextANGLE(GLeglContext ctx, GLuint path)
+{
+    return gl::IsPathCHROMIUMContextANGLE(ctx, path);
+}
+
+void GL_APIENTRY glPathCommandsCHROMIUMContextANGLE(GLeglContext ctx,
+                                                    GLuint path,
+                                                    GLsizei numCommands,
+                                                    const GLubyte *commands,
+                                                    GLsizei numCoords,
+                                                    GLenum coordType,
+                                                    const void *coords)
+{
+    return gl::PathCommandsCHROMIUMContextANGLE(ctx, path, numCommands, commands, numCoords,
+                                                coordType, coords);
+}
+
+void GL_APIENTRY glPathParameterfCHROMIUMContextANGLE(GLeglContext ctx,
+                                                      GLuint path,
+                                                      GLenum pname,
+                                                      GLfloat value)
+{
+    return gl::PathParameterfCHROMIUMContextANGLE(ctx, path, pname, value);
+}
+
+void GL_APIENTRY glPathParameteriCHROMIUMContextANGLE(GLeglContext ctx,
+                                                      GLuint path,
+                                                      GLenum pname,
+                                                      GLint value)
+{
+    return gl::PathParameteriCHROMIUMContextANGLE(ctx, path, pname, value);
+}
+
+void GL_APIENTRY glGetPathParameterfvCHROMIUMContextANGLE(GLeglContext ctx,
+                                                          GLuint path,
+                                                          GLenum pname,
+                                                          GLfloat *value)
+{
+    return gl::GetPathParameterfvCHROMIUMContextANGLE(ctx, path, pname, value);
+}
+
+void GL_APIENTRY glGetPathParameterivCHROMIUMContextANGLE(GLeglContext ctx,
+                                                          GLuint path,
+                                                          GLenum pname,
+                                                          GLint *value)
+{
+    return gl::GetPathParameterivCHROMIUMContextANGLE(ctx, path, pname, value);
+}
+
+void GL_APIENTRY glPathStencilFuncCHROMIUMContextANGLE(GLeglContext ctx,
+                                                       GLenum func,
+                                                       GLint ref,
+                                                       GLuint mask)
+{
+    return gl::PathStencilFuncCHROMIUMContextANGLE(ctx, func, ref, mask);
+}
+
+void GL_APIENTRY glStencilFillPathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                       GLuint path,
+                                                       GLenum fillMode,
+                                                       GLuint mask)
+{
+    return gl::StencilFillPathCHROMIUMContextANGLE(ctx, path, fillMode, mask);
+}
+
+void GL_APIENTRY glStencilStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                         GLuint path,
+                                                         GLint reference,
+                                                         GLuint mask)
+{
+    return gl::StencilStrokePathCHROMIUMContextANGLE(ctx, path, reference, mask);
+}
+
+void GL_APIENTRY glCoverFillPathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                     GLuint path,
+                                                     GLenum coverMode)
+{
+    return gl::CoverFillPathCHROMIUMContextANGLE(ctx, path, coverMode);
+}
+
+void GL_APIENTRY glCoverStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                       GLuint path,
+                                                       GLenum coverMode)
+{
+    return gl::CoverStrokePathCHROMIUMContextANGLE(ctx, path, coverMode);
+}
+
+void GL_APIENTRY glStencilThenCoverFillPathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                GLuint path,
+                                                                GLenum fillMode,
+                                                                GLuint mask,
+                                                                GLenum coverMode)
+{
+    return gl::StencilThenCoverFillPathCHROMIUMContextANGLE(ctx, path, fillMode, mask, coverMode);
+}
+
+void GL_APIENTRY glStencilThenCoverStrokePathCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                  GLuint path,
+                                                                  GLint reference,
+                                                                  GLuint mask,
+                                                                  GLenum coverMode)
+{
+    return gl::StencilThenCoverStrokePathCHROMIUMContextANGLE(ctx, path, reference, mask,
+                                                              coverMode);
+}
+
+void GL_APIENTRY glCoverFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                              GLsizei numPath,
+                                                              GLenum pathNameType,
+                                                              const void *paths,
+                                                              GLuint pathBase,
+                                                              GLenum coverMode,
+                                                              GLenum transformType,
+                                                              const GLfloat *transformValues)
+{
+    return gl::CoverFillPathInstancedCHROMIUMContextANGLE(
+        ctx, numPath, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
+}
+
+void GL_APIENTRY glCoverStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                GLsizei numPath,
+                                                                GLenum pathNameType,
+                                                                const void *paths,
+                                                                GLuint pathBase,
+                                                                GLenum coverMode,
+                                                                GLenum transformType,
+                                                                const GLfloat *transformValues)
+{
+    return gl::CoverStrokePathInstancedCHROMIUMContextANGLE(
+        ctx, numPath, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
+}
+
+void GL_APIENTRY glStencilStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                  GLsizei numPath,
+                                                                  GLenum pathNameType,
+                                                                  const void *paths,
+                                                                  GLuint pathBase,
+                                                                  GLint reference,
+                                                                  GLuint mask,
+                                                                  GLenum transformType,
+                                                                  const GLfloat *transformValues)
+{
+    return gl::StencilStrokePathInstancedCHROMIUMContextANGLE(ctx, numPath, pathNameType, paths,
+                                                              pathBase, reference, mask,
+                                                              transformType, transformValues);
+}
+
+void GL_APIENTRY glStencilFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                GLsizei numPaths,
+                                                                GLenum pathNameType,
+                                                                const void *paths,
+                                                                GLuint pathBase,
+                                                                GLenum fillMode,
+                                                                GLuint mask,
+                                                                GLenum transformType,
+                                                                const GLfloat *transformValues)
+{
+    return gl::StencilFillPathInstancedCHROMIUMContextANGLE(ctx, numPaths, pathNameType, paths,
+                                                            pathBase, fillMode, mask, transformType,
+                                                            transformValues);
+}
+
+void GL_APIENTRY
+glStencilThenCoverFillPathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                        GLsizei numPaths,
+                                                        GLenum pathNameType,
+                                                        const void *paths,
+                                                        GLuint pathBase,
+                                                        GLenum fillMode,
+                                                        GLuint mask,
+                                                        GLenum coverMode,
+                                                        GLenum transformType,
+                                                        const GLfloat *transformValues)
+{
+    return gl::StencilThenCoverFillPathInstancedCHROMIUMContextANGLE(
+        ctx, numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType,
+        transformValues);
+}
+
+void GL_APIENTRY
+glStencilThenCoverStrokePathInstancedCHROMIUMContextANGLE(GLeglContext ctx,
+                                                          GLsizei numPaths,
+                                                          GLenum pathNameType,
+                                                          const void *paths,
+                                                          GLuint pathBase,
+                                                          GLint reference,
+                                                          GLuint mask,
+                                                          GLenum coverMode,
+                                                          GLenum transformType,
+                                                          const GLfloat *transformValues)
+{
+    return gl::StencilThenCoverStrokePathInstancedCHROMIUMContextANGLE(
+        ctx, numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType,
+        transformValues);
+}
+
+void GL_APIENTRY glBindFragmentInputLocationCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                 GLuint programs,
+                                                                 GLint location,
+                                                                 const GLchar *name)
+{
+    return gl::BindFragmentInputLocationCHROMIUMContextANGLE(ctx, programs, location, name);
+}
+
+void GL_APIENTRY glProgramPathFragmentInputGenCHROMIUMContextANGLE(GLeglContext ctx,
+                                                                   GLuint program,
+                                                                   GLint location,
+                                                                   GLenum genMode,
+                                                                   GLint components,
+                                                                   const GLfloat *coeffs)
+{
+    return gl::ProgramPathFragmentInputGenCHROMIUMContextANGLE(ctx, program, location, genMode,
+                                                               components, coeffs);
+}
+
+void GL_APIENTRY glCopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                   GLuint sourceId,
+                                                   GLint sourceLevel,
+                                                   GLenum destTarget,
+                                                   GLuint destId,
+                                                   GLint destLevel,
+                                                   GLint internalFormat,
+                                                   GLenum destType,
+                                                   GLboolean unpackFlipY,
+                                                   GLboolean unpackPremultiplyAlpha,
+                                                   GLboolean unpackUnmultiplyAlpha)
+{
+    return gl::CopyTextureCHROMIUMContextANGLE(ctx, sourceId, sourceLevel, destTarget, destId,
+                                               destLevel, internalFormat, destType, unpackFlipY,
+                                               unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void GL_APIENTRY glCopySubTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                      GLuint sourceId,
+                                                      GLint sourceLevel,
+                                                      GLenum destTarget,
+                                                      GLuint destId,
+                                                      GLint destLevel,
+                                                      GLint xoffset,
+                                                      GLint yoffset,
+                                                      GLint x,
+                                                      GLint y,
+                                                      GLint width,
+                                                      GLint height,
+                                                      GLboolean unpackFlipY,
+                                                      GLboolean unpackPremultiplyAlpha,
+                                                      GLboolean unpackUnmultiplyAlpha)
+{
+    return gl::CopySubTextureCHROMIUMContextANGLE(
+        ctx, sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, x, y, width,
+        height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void GL_APIENTRY glCompressedCopyTextureCHROMIUMContextANGLE(GLeglContext ctx,
+                                                             GLuint sourceId,
+                                                             GLuint destId)
+{
+    return gl::CompressedCopyTextureCHROMIUMContextANGLE(ctx, sourceId, destId);
+}
+
+void GL_APIENTRY glRequestExtensionANGLEContextANGLE(GLeglContext ctx, const GLchar *name)
+{
+    return gl::RequestExtensionANGLEContextANGLE(ctx, name);
+}
+
+void GL_APIENTRY glGetBooleanvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLboolean *params)
+{
+    return gl::GetBooleanvRobustANGLEContextANGLE(ctx, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetBufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               GLsizei *length,
+                                                               GLint *params)
+{
+    return gl::GetBufferParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
+                                                           params);
+}
+
+void GL_APIENTRY glGetFloatvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei *length,
+                                                    GLfloat *params)
+{
+    return gl::GetFloatvRobustANGLEContextANGLE(ctx, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetFramebufferAttachmentParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                              GLenum target,
+                                                                              GLenum attachment,
+                                                                              GLenum pname,
+                                                                              GLsizei bufSize,
+                                                                              GLsizei *length,
+                                                                              GLint *params)
+{
+    return gl::GetFramebufferAttachmentParameterivRobustANGLEContextANGLE(
+        ctx, target, attachment, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetIntegervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *data)
+{
+    return gl::GetIntegervRobustANGLEContextANGLE(ctx, pname, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetProgramivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLint *params)
+{
+    return gl::GetProgramivRobustANGLEContextANGLE(ctx, program, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetRenderbufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                     GLenum target,
+                                                                     GLenum pname,
+                                                                     GLsizei bufSize,
+                                                                     GLsizei *length,
+                                                                     GLint *params)
+{
+    return gl::GetRenderbufferParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize,
+                                                                 length, params);
+}
+
+void GL_APIENTRY glGetShaderivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLuint shader,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLint *params)
+{
+    return gl::GetShaderivRobustANGLEContextANGLE(ctx, shader, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetTexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLfloat *params)
+{
+    return gl::GetTexParameterfvRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
+                                                        params);
+}
+
+void GL_APIENTRY glGetTexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint *params)
+{
+    return gl::GetTexParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
+                                                        params);
+}
+
+void GL_APIENTRY glGetUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLfloat *params)
+{
+    return gl::GetUniformfvRobustANGLEContextANGLE(ctx, program, location, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetUniformivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                       GLuint program,
+                                                       GLint location,
+                                                       GLsizei bufSize,
+                                                       GLsizei *length,
+                                                       GLint *params)
+{
+    return gl::GetUniformivRobustANGLEContextANGLE(ctx, program, location, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetVertexAttribfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLuint index,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLfloat *params)
+{
+    return gl::GetVertexAttribfvRobustANGLEContextANGLE(ctx, index, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetVertexAttribivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLuint index,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLint *params)
+{
+    return gl::GetVertexAttribivRobustANGLEContextANGLE(ctx, index, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetVertexAttribPointervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLuint index,
+                                                                  GLenum pname,
+                                                                  GLsizei bufSize,
+                                                                  GLsizei *length,
+                                                                  void **pointer)
+{
+    return gl::GetVertexAttribPointervRobustANGLEContextANGLE(ctx, index, pname, bufSize, length,
+                                                              pointer);
+}
+
+void GL_APIENTRY glReadPixelsRobustANGLEContextANGLE(GLeglContext ctx,
+                                                     GLint x,
+                                                     GLint y,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLenum format,
+                                                     GLenum type,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLsizei *columns,
+                                                     GLsizei *rows,
+                                                     void *pixels)
+{
+    return gl::ReadPixelsRobustANGLEContextANGLE(ctx, x, y, width, height, format, type, bufSize,
+                                                 length, columns, rows, pixels);
+}
+
+void GL_APIENTRY glTexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLint level,
+                                                     GLint internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLint border,
+                                                     GLenum format,
+                                                     GLenum type,
+                                                     GLsizei bufSize,
+                                                     const void *pixels)
+{
+    return gl::TexImage2DRobustANGLEContextANGLE(ctx, target, level, internalformat, width, height,
+                                                 border, format, type, bufSize, pixels);
+}
+
+void GL_APIENTRY glTexParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         const GLfloat *params)
+{
+    return gl::TexParameterfvRobustANGLEContextANGLE(ctx, target, pname, bufSize, params);
+}
+
+void GL_APIENTRY glTexParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                         GLenum target,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         const GLint *params)
+{
+    return gl::TexParameterivRobustANGLEContextANGLE(ctx, target, pname, bufSize, params);
+}
+
+void GL_APIENTRY glTexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLint level,
+                                                        GLint xoffset,
+                                                        GLint yoffset,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLenum format,
+                                                        GLenum type,
+                                                        GLsizei bufSize,
+                                                        const void *pixels)
+{
+    return gl::TexSubImage2DRobustANGLEContextANGLE(ctx, target, level, xoffset, yoffset, width,
+                                                    height, format, type, bufSize, pixels);
+}
+
+void GL_APIENTRY glTexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLint level,
+                                                     GLint internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height,
+                                                     GLsizei depth,
+                                                     GLint border,
+                                                     GLenum format,
+                                                     GLenum type,
+                                                     GLsizei bufSize,
+                                                     const void *pixels)
+{
+    return gl::TexImage3DRobustANGLEContextANGLE(ctx, target, level, internalformat, width, height,
+                                                 depth, border, format, type, bufSize, pixels);
+}
+
+void GL_APIENTRY glTexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLint level,
+                                                        GLint xoffset,
+                                                        GLint yoffset,
+                                                        GLint zoffset,
+                                                        GLsizei width,
+                                                        GLsizei height,
+                                                        GLsizei depth,
+                                                        GLenum format,
+                                                        GLenum type,
+                                                        GLsizei bufSize,
+                                                        const void *pixels)
+{
+    return gl::TexSubImage3DRobustANGLEContextANGLE(ctx, target, level, xoffset, yoffset, zoffset,
+                                                    width, height, depth, format, type, bufSize,
+                                                    pixels);
+}
+
+void GL_APIENTRY glCompressedTexImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLint level,
+                                                               GLenum internalformat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               GLint border,
+                                                               GLsizei imageSize,
+                                                               GLsizei dataSize,
+                                                               const GLvoid *data)
+{
+    return gl::CompressedTexImage2DRobustANGLEContextANGLE(
+        ctx, target, level, internalformat, width, height, border, imageSize, dataSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage2DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLint level,
+                                                                  GLsizei xoffset,
+                                                                  GLsizei yoffset,
+                                                                  GLsizei width,
+                                                                  GLsizei height,
+                                                                  GLenum format,
+                                                                  GLsizei imageSize,
+                                                                  GLsizei dataSize,
+                                                                  const GLvoid *data)
+{
+    return gl::CompressedTexSubImage2DRobustANGLEContextANGLE(
+        ctx, target, level, xoffset, yoffset, width, height, format, imageSize, dataSize, data);
+}
+
+void GL_APIENTRY glCompressedTexImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum target,
+                                                               GLint level,
+                                                               GLenum internalformat,
+                                                               GLsizei width,
+                                                               GLsizei height,
+                                                               GLsizei depth,
+                                                               GLint border,
+                                                               GLsizei imageSize,
+                                                               GLsizei dataSize,
+                                                               const GLvoid *data)
+{
+    return gl::CompressedTexImage3DRobustANGLEContextANGLE(ctx, target, level, internalformat,
+                                                           width, height, depth, border, imageSize,
+                                                           dataSize, data);
+}
+
+void GL_APIENTRY glCompressedTexSubImage3DRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLenum target,
+                                                                  GLint level,
+                                                                  GLint xoffset,
+                                                                  GLint yoffset,
+                                                                  GLint zoffset,
+                                                                  GLsizei width,
+                                                                  GLsizei height,
+                                                                  GLsizei depth,
+                                                                  GLenum format,
+                                                                  GLsizei imageSize,
+                                                                  GLsizei dataSize,
+                                                                  const GLvoid *data)
+{
+    return gl::CompressedTexSubImage3DRobustANGLEContextANGLE(ctx, target, level, xoffset, yoffset,
+                                                              zoffset, width, height, depth, format,
+                                                              imageSize, dataSize, data);
+}
+
+void GL_APIENTRY glGetQueryivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                     GLenum target,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei *length,
+                                                     GLint *params)
+{
+    return gl::GetQueryivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetQueryObjectuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLuint id,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            GLuint *params)
+{
+    return gl::GetQueryObjectuivRobustANGLEContextANGLE(ctx, id, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetBufferPointervRobustANGLEContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLenum pname,
+                                                            GLsizei bufSize,
+                                                            GLsizei *length,
+                                                            void **params)
+{
+    return gl::GetBufferPointervRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
+                                                        params);
+}
+
+void GL_APIENTRY glGetIntegeri_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLuint index,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint *data)
+{
+    return gl::GetIntegeri_vRobustANGLEContextANGLE(ctx, target, index, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetInternalformativRobustANGLEContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLenum internalformat,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLint *params)
+{
+    return gl::GetInternalformativRobustANGLEContextANGLE(ctx, target, internalformat, pname,
+                                                          bufSize, length, params);
+}
+
+void GL_APIENTRY glGetVertexAttribIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLuint index,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLint *params)
+{
+    return gl::GetVertexAttribIivRobustANGLEContextANGLE(ctx, index, pname, bufSize, length,
+                                                         params);
+}
+
+void GL_APIENTRY glGetVertexAttribIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                              GLuint index,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLuint *params)
+{
+    return gl::GetVertexAttribIuivRobustANGLEContextANGLE(ctx, index, pname, bufSize, length,
+                                                          params);
+}
+
+void GL_APIENTRY glGetUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLuint program,
+                                                        GLint location,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLuint *params)
+{
+    return gl::GetUniformuivRobustANGLEContextANGLE(ctx, program, location, bufSize, length,
+                                                    params);
+}
+
+void GL_APIENTRY glGetActiveUniformBlockivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLuint program,
+                                                                  GLuint uniformBlockIndex,
+                                                                  GLenum pname,
+                                                                  GLsizei bufSize,
+                                                                  GLsizei *length,
+                                                                  GLint *params)
+{
+    return gl::GetActiveUniformBlockivRobustANGLEContextANGLE(ctx, program, uniformBlockIndex,
+                                                              pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetInteger64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum pname,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint64 *data)
+{
+    return gl::GetInteger64vRobustANGLEContextANGLE(ctx, pname, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetInteger64i_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLuint index,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLint64 *data)
+{
+    return gl::GetInteger64i_vRobustANGLEContextANGLE(ctx, target, index, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetBufferParameteri64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLint64 *params)
+{
+    return gl::GetBufferParameteri64vRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
+                                                             params);
+}
+
+void GL_APIENTRY glSamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLuint sampler,
+                                                             GLuint pname,
+                                                             GLsizei bufSize,
+                                                             const GLint *param)
+{
+    return gl::SamplerParameterivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, param);
+}
+
+void GL_APIENTRY glSamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLuint sampler,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             const GLfloat *param)
+{
+    return gl::SamplerParameterfvRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, param);
+}
+
+void GL_APIENTRY glGetSamplerParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLuint sampler,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint *params)
+{
+    return gl::GetSamplerParameterivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, length,
+                                                            params);
+}
+
+void GL_APIENTRY glGetSamplerParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLuint sampler,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLfloat *params)
+{
+    return gl::GetSamplerParameterfvRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, length,
+                                                            params);
+}
+
+void GL_APIENTRY glGetFramebufferParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                    GLuint sampler,
+                                                                    GLenum pname,
+                                                                    GLsizei bufSize,
+                                                                    GLsizei *length,
+                                                                    GLint *params)
+{
+    return gl::GetFramebufferParameterivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize,
+                                                                length, params);
+}
+
+void GL_APIENTRY glGetProgramInterfaceivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                GLuint program,
+                                                                GLenum programInterface,
+                                                                GLenum pname,
+                                                                GLsizei bufSize,
+                                                                GLsizei *length,
+                                                                GLint *params)
+{
+    return gl::GetProgramInterfaceivRobustANGLEContextANGLE(ctx, program, programInterface, pname,
+                                                            bufSize, length, params);
+}
+
+void GL_APIENTRY glGetBooleani_vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLenum target,
+                                                        GLuint index,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLboolean *data)
+{
+    return gl::GetBooleani_vRobustANGLEContextANGLE(ctx, target, index, bufSize, length, data);
+}
+
+void GL_APIENTRY glGetMultisamplefvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLenum pname,
+                                                           GLuint index,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLfloat *val)
+{
+    return gl::GetMultisamplefvRobustANGLEContextANGLE(ctx, pname, index, bufSize, length, val);
+}
+
+void GL_APIENTRY glGetTexLevelParameterivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLint level,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLint *params)
+{
+    return gl::GetTexLevelParameterivRobustANGLEContextANGLE(ctx, target, level, pname, bufSize,
+                                                             length, params);
+}
+
+void GL_APIENTRY glGetTexLevelParameterfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLenum target,
+                                                                 GLint level,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLfloat *params)
+{
+    return gl::GetTexLevelParameterfvRobustANGLEContextANGLE(ctx, target, level, pname, bufSize,
+                                                             length, params);
+}
+
+void GL_APIENTRY glGetPointervRobustANGLERobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 void **params)
+{
+    return gl::GetPointervRobustANGLERobustANGLEContextANGLE(ctx, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glReadnPixelsRobustANGLEContextANGLE(GLeglContext ctx,
+                                                      GLint x,
+                                                      GLint y,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLenum format,
+                                                      GLenum type,
+                                                      GLsizei bufSize,
+                                                      GLsizei *length,
+                                                      GLsizei *columns,
+                                                      GLsizei *rows,
+                                                      void *data)
+{
+    return gl::ReadnPixelsRobustANGLEContextANGLE(ctx, x, y, width, height, format, type, bufSize,
+                                                  length, columns, rows, data);
+}
+
+void GL_APIENTRY glGetnUniformfvRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLuint program,
+                                                        GLint location,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLfloat *params)
+{
+    return gl::GetnUniformfvRobustANGLEContextANGLE(ctx, program, location, bufSize, length,
+                                                    params);
+}
+
+void GL_APIENTRY glGetnUniformivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                        GLuint program,
+                                                        GLint location,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLint *params)
+{
+    return gl::GetnUniformivRobustANGLEContextANGLE(ctx, program, location, bufSize, length,
+                                                    params);
+}
+
+void GL_APIENTRY glGetnUniformuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                         GLuint program,
+                                                         GLint location,
+                                                         GLsizei bufSize,
+                                                         GLsizei *length,
+                                                         GLuint *params)
+{
+    return gl::GetnUniformuivRobustANGLEContextANGLE(ctx, program, location, bufSize, length,
+                                                     params);
+}
+
+void GL_APIENTRY glTexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                          GLenum target,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          const GLint *params)
+{
+    return gl::TexParameterIivRobustANGLEContextANGLE(ctx, target, pname, bufSize, params);
+}
+
+void GL_APIENTRY glTexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           const GLuint *params)
+{
+    return gl::TexParameterIuivRobustANGLEContextANGLE(ctx, target, pname, bufSize, params);
+}
+
+void GL_APIENTRY glGetTexParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLenum target,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLint *params)
+{
+    return gl::GetTexParameterIivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
+                                                         params);
+}
+
+void GL_APIENTRY glGetTexParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                              GLenum target,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLuint *params)
+{
+    return gl::GetTexParameterIuivRobustANGLEContextANGLE(ctx, target, pname, bufSize, length,
+                                                          params);
+}
+
+void GL_APIENTRY glSamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                              GLuint sampler,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              const GLint *param)
+{
+    return gl::SamplerParameterIivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, param);
+}
+
+void GL_APIENTRY glSamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                               GLuint sampler,
+                                                               GLenum pname,
+                                                               GLsizei bufSize,
+                                                               const GLuint *param)
+{
+    return gl::SamplerParameterIuivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, param);
+}
+
+void GL_APIENTRY glGetSamplerParameterIivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                 GLuint sampler,
+                                                                 GLenum pname,
+                                                                 GLsizei bufSize,
+                                                                 GLsizei *length,
+                                                                 GLint *params)
+{
+    return gl::GetSamplerParameterIivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, length,
+                                                             params);
+}
+
+void GL_APIENTRY glGetSamplerParameterIuivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                                  GLuint sampler,
+                                                                  GLenum pname,
+                                                                  GLsizei bufSize,
+                                                                  GLsizei *length,
+                                                                  GLuint *params)
+{
+    return gl::GetSamplerParameterIuivRobustANGLEContextANGLE(ctx, sampler, pname, bufSize, length,
+                                                              params);
+}
+
+void GL_APIENTRY glGetQueryObjectivRobustANGLEContextANGLE(GLeglContext ctx,
+                                                           GLuint id,
+                                                           GLenum pname,
+                                                           GLsizei bufSize,
+                                                           GLsizei *length,
+                                                           GLint *params)
+{
+    return gl::GetQueryObjectivRobustANGLEContextANGLE(ctx, id, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetQueryObjecti64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                             GLuint id,
+                                                             GLenum pname,
+                                                             GLsizei bufSize,
+                                                             GLsizei *length,
+                                                             GLint64 *params)
+{
+    return gl::GetQueryObjecti64vRobustANGLEContextANGLE(ctx, id, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glGetQueryObjectui64vRobustANGLEContextANGLE(GLeglContext ctx,
+                                                              GLuint id,
+                                                              GLenum pname,
+                                                              GLsizei bufSize,
+                                                              GLsizei *length,
+                                                              GLuint64 *params)
+{
+    return gl::GetQueryObjectui64vRobustANGLEContextANGLE(ctx, id, pname, bufSize, length, params);
+}
+
+void GL_APIENTRY glCopyTexture3DANGLEContextANGLE(GLeglContext ctx,
+                                                  GLuint sourceId,
+                                                  GLint sourceLevel,
+                                                  GLenum destTarget,
+                                                  GLuint destId,
+                                                  GLint destLevel,
+                                                  GLint internalFormat,
+                                                  GLenum destType,
+                                                  GLboolean unpackFlipY,
+                                                  GLboolean unpackPremultiplyAlpha,
+                                                  GLboolean unpackUnmultiplyAlpha)
+{
+    return gl::CopyTexture3DANGLEContextANGLE(ctx, sourceId, sourceLevel, destTarget, destId,
+                                              destLevel, internalFormat, destType, unpackFlipY,
+                                              unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void GL_APIENTRY glCopySubTexture3DANGLEContextANGLE(GLeglContext ctx,
+                                                     GLuint sourceId,
+                                                     GLint sourceLevel,
+                                                     GLenum destTarget,
+                                                     GLuint destId,
+                                                     GLint destLevel,
+                                                     GLint xoffset,
+                                                     GLint yoffset,
+                                                     GLint zoffset,
+                                                     GLint x,
+                                                     GLint y,
+                                                     GLint z,
+                                                     GLint width,
+                                                     GLint height,
+                                                     GLint depth,
+                                                     GLboolean unpackFlipY,
+                                                     GLboolean unpackPremultiplyAlpha,
+                                                     GLboolean unpackUnmultiplyAlpha)
+{
+    return gl::CopySubTexture3DANGLEContextANGLE(
+        ctx, sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, yoffset, zoffset, x, y,
+        z, width, height, depth, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void GL_APIENTRY glTexStorage2DMultisampleANGLEContextANGLE(GLeglContext ctx,
+                                                            GLenum target,
+                                                            GLsizei samples,
+                                                            GLenum internalformat,
+                                                            GLsizei width,
+                                                            GLsizei height,
+                                                            GLboolean fixedsamplelocations)
+{
+    return gl::TexStorage2DMultisampleANGLEContextANGLE(ctx, target, samples, internalformat, width,
+                                                        height, fixedsamplelocations);
+}
+
+void GL_APIENTRY glGetTexLevelParameterivANGLEContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLint level,
+                                                           GLenum pname,
+                                                           GLint *params)
+{
+    return gl::GetTexLevelParameterivANGLEContextANGLE(ctx, target, level, pname, params);
+}
+
+void GL_APIENTRY glGetTexLevelParameterfvANGLEContextANGLE(GLeglContext ctx,
+                                                           GLenum target,
+                                                           GLint level,
+                                                           GLenum pname,
+                                                           GLfloat *params)
+{
+    return gl::GetTexLevelParameterfvANGLEContextANGLE(ctx, target, level, pname, params);
+}
+
+void GL_APIENTRY glMultiDrawArraysANGLEContextANGLE(GLeglContext ctx,
+                                                    GLenum mode,
+                                                    const GLint *firsts,
+                                                    const GLsizei *counts,
+                                                    GLsizei drawcount)
+{
+    return gl::MultiDrawArraysANGLEContextANGLE(ctx, mode, firsts, counts, drawcount);
+}
+
+void GL_APIENTRY glMultiDrawArraysInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                             GLenum mode,
+                                                             const GLint *firsts,
+                                                             const GLsizei *counts,
+                                                             const GLsizei *instanceCounts,
+                                                             GLsizei drawcount)
+{
+    return gl::MultiDrawArraysInstancedANGLEContextANGLE(ctx, mode, firsts, counts, instanceCounts,
+                                                         drawcount);
+}
+
+void GL_APIENTRY glMultiDrawElementsANGLEContextANGLE(GLeglContext ctx,
+                                                      GLenum mode,
+                                                      const GLsizei *counts,
+                                                      GLenum type,
+                                                      const GLvoid *const *indices,
+                                                      GLsizei drawcount)
+{
+    return gl::MultiDrawElementsANGLEContextANGLE(ctx, mode, counts, type, indices, drawcount);
+}
+
+void GL_APIENTRY glMultiDrawElementsInstancedANGLEContextANGLE(GLeglContext ctx,
+                                                               GLenum mode,
+                                                               const GLsizei *counts,
+                                                               GLenum type,
+                                                               const GLvoid *const *indices,
+                                                               const GLsizei *instanceCounts,
+                                                               GLsizei drawcount)
+{
+    return gl::MultiDrawElementsInstancedANGLEContextANGLE(ctx, mode, counts, type, indices,
+                                                           instanceCounts, drawcount);
+}
+
+void GL_APIENTRY glGetMultisamplefvANGLEContextANGLE(GLeglContext ctx,
+                                                     GLenum pname,
+                                                     GLuint index,
+                                                     GLfloat *val)
+{
+    return gl::GetMultisamplefvANGLEContextANGLE(ctx, pname, index, val);
+}
+
+void GL_APIENTRY glSampleMaskiANGLEContextANGLE(GLeglContext ctx,
+                                                GLuint maskNumber,
+                                                GLbitfield mask)
+{
+    return gl::SampleMaskiANGLEContextANGLE(ctx, maskNumber, mask);
+}
+
+void GL_APIENTRY glProvokingVertexANGLEContextANGLE(GLeglContext ctx, GLenum mode)
+{
+    return gl::ProvokingVertexANGLEContextANGLE(ctx, mode);
+}
+
+void GL_APIENTRY glLoseContextCHROMIUMContextANGLE(GLeglContext ctx, GLenum current, GLenum other)
+{
+    return gl::LoseContextCHROMIUMContextANGLE(ctx, current, other);
+}
+
+void GL_APIENTRY glTexImage2DExternalANGLEContextANGLE(GLeglContext ctx,
+                                                       GLenum target,
+                                                       GLint level,
+                                                       GLint internalformat,
+                                                       GLsizei width,
+                                                       GLsizei height,
+                                                       GLint border,
+                                                       GLenum format,
+                                                       GLenum type)
+{
+    return gl::TexImage2DExternalANGLEContextANGLE(ctx, target, level, internalformat, width,
+                                                   height, border, format, type);
+}
+
+void GL_APIENTRY glInvalidateTextureANGLEContextANGLE(GLeglContext ctx, GLenum target)
+{
+    return gl::InvalidateTextureANGLEContextANGLE(ctx, target);
+}
+
+}  // extern "C"
diff --git a/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.def b/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.def
new file mode 100644
index 0000000000..803a8022e4
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.def
@@ -0,0 +1,1572 @@
+; GENERATED FILE - DO NOT EDIT.
+; Generated by generate_entry_points.py using data from Khronos and ANGLE XML files.
+;
+; Copyright 2019 The ANGLE Project Authors. All rights reserved.
+; Use of this source code is governed by a BSD-style license that can be
+; found in the LICENSE file.
+LIBRARY libGLESv2
+EXPORTS
+
+    ; OpenGL ES 2.0
+    glActiveTexture
+    glAttachShader
+    glBindAttribLocation
+    glBindBuffer
+    glBindFramebuffer
+    glBindRenderbuffer
+    glBindTexture
+    glBlendColor
+    glBlendEquation
+    glBlendEquationSeparate
+    glBlendFunc
+    glBlendFuncSeparate
+    glBufferData
+    glBufferSubData
+    glCheckFramebufferStatus
+    glClear
+    glClearColor
+    glClearDepthf
+    glClearStencil
+    glColorMask
+    glCompileShader
+    glCompressedTexImage2D
+    glCompressedTexSubImage2D
+    glCopyTexImage2D
+    glCopyTexSubImage2D
+    glCreateProgram
+    glCreateShader
+    glCullFace
+    glDeleteBuffers
+    glDeleteFramebuffers
+    glDeleteProgram
+    glDeleteRenderbuffers
+    glDeleteShader
+    glDeleteTextures
+    glDepthFunc
+    glDepthMask
+    glDepthRangef
+    glDetachShader
+    glDisable
+    glDisableVertexAttribArray
+    glDrawArrays
+    glDrawElements
+    glEnable
+    glEnableVertexAttribArray
+    glFinish
+    glFlush
+    glFramebufferRenderbuffer
+    glFramebufferTexture2D
+    glFrontFace
+    glGenBuffers
+    glGenFramebuffers
+    glGenRenderbuffers
+    glGenTextures
+    glGenerateMipmap
+    glGetActiveAttrib
+    glGetActiveUniform
+    glGetAttachedShaders
+    glGetAttribLocation
+    glGetBooleanv
+    glGetBufferParameteriv
+    glGetError
+    glGetFloatv
+    glGetFramebufferAttachmentParameteriv
+    glGetIntegerv
+    glGetProgramInfoLog
+    glGetProgramiv
+    glGetRenderbufferParameteriv
+    glGetShaderInfoLog
+    glGetShaderPrecisionFormat
+    glGetShaderSource
+    glGetShaderiv
+    glGetString
+    glGetTexParameterfv
+    glGetTexParameteriv
+    glGetUniformLocation
+    glGetUniformfv
+    glGetUniformiv
+    glGetVertexAttribPointerv
+    glGetVertexAttribfv
+    glGetVertexAttribiv
+    glHint
+    glIsBuffer
+    glIsEnabled
+    glIsFramebuffer
+    glIsProgram
+    glIsRenderbuffer
+    glIsShader
+    glIsTexture
+    glLineWidth
+    glLinkProgram
+    glPixelStorei
+    glPolygonOffset
+    glReadPixels
+    glReleaseShaderCompiler
+    glRenderbufferStorage
+    glSampleCoverage
+    glScissor
+    glShaderBinary
+    glShaderSource
+    glStencilFunc
+    glStencilFuncSeparate
+    glStencilMask
+    glStencilMaskSeparate
+    glStencilOp
+    glStencilOpSeparate
+    glTexImage2D
+    glTexParameterf
+    glTexParameterfv
+    glTexParameteri
+    glTexParameteriv
+    glTexSubImage2D
+    glUniform1f
+    glUniform1fv
+    glUniform1i
+    glUniform1iv
+    glUniform2f
+    glUniform2fv
+    glUniform2i
+    glUniform2iv
+    glUniform3f
+    glUniform3fv
+    glUniform3i
+    glUniform3iv
+    glUniform4f
+    glUniform4fv
+    glUniform4i
+    glUniform4iv
+    glUniformMatrix2fv
+    glUniformMatrix3fv
+    glUniformMatrix4fv
+    glUseProgram
+    glValidateProgram
+    glVertexAttrib1f
+    glVertexAttrib1fv
+    glVertexAttrib2f
+    glVertexAttrib2fv
+    glVertexAttrib3f
+    glVertexAttrib3fv
+    glVertexAttrib4f
+    glVertexAttrib4fv
+    glVertexAttribPointer
+    glViewport
+
+    ; OpenGL ES 3.0
+    glBeginQuery
+    glBeginTransformFeedback
+    glBindBufferBase
+    glBindBufferRange
+    glBindSampler
+    glBindTransformFeedback
+    glBindVertexArray
+    glBlitFramebuffer
+    glClearBufferfi
+    glClearBufferfv
+    glClearBufferiv
+    glClearBufferuiv
+    glClientWaitSync
+    glCompressedTexImage3D
+    glCompressedTexSubImage3D
+    glCopyBufferSubData
+    glCopyTexSubImage3D
+    glDeleteQueries
+    glDeleteSamplers
+    glDeleteSync
+    glDeleteTransformFeedbacks
+    glDeleteVertexArrays
+    glDrawArraysInstanced
+    glDrawBuffers
+    glDrawElementsInstanced
+    glDrawRangeElements
+    glEndQuery
+    glEndTransformFeedback
+    glFenceSync
+    glFlushMappedBufferRange
+    glFramebufferTextureLayer
+    glGenQueries
+    glGenSamplers
+    glGenTransformFeedbacks
+    glGenVertexArrays
+    glGetActiveUniformBlockName
+    glGetActiveUniformBlockiv
+    glGetActiveUniformsiv
+    glGetBufferParameteri64v
+    glGetBufferPointerv
+    glGetFragDataLocation
+    glGetInteger64i_v
+    glGetInteger64v
+    glGetIntegeri_v
+    glGetInternalformativ
+    glGetProgramBinary
+    glGetQueryObjectuiv
+    glGetQueryiv
+    glGetSamplerParameterfv
+    glGetSamplerParameteriv
+    glGetStringi
+    glGetSynciv
+    glGetTransformFeedbackVarying
+    glGetUniformBlockIndex
+    glGetUniformIndices
+    glGetUniformuiv
+    glGetVertexAttribIiv
+    glGetVertexAttribIuiv
+    glInvalidateFramebuffer
+    glInvalidateSubFramebuffer
+    glIsQuery
+    glIsSampler
+    glIsSync
+    glIsTransformFeedback
+    glIsVertexArray
+    glMapBufferRange
+    glPauseTransformFeedback
+    glProgramBinary
+    glProgramParameteri
+    glReadBuffer
+    glRenderbufferStorageMultisample
+    glResumeTransformFeedback
+    glSamplerParameterf
+    glSamplerParameterfv
+    glSamplerParameteri
+    glSamplerParameteriv
+    glTexImage3D
+    glTexStorage2D
+    glTexStorage3D
+    glTexSubImage3D
+    glTransformFeedbackVaryings
+    glUniform1ui
+    glUniform1uiv
+    glUniform2ui
+    glUniform2uiv
+    glUniform3ui
+    glUniform3uiv
+    glUniform4ui
+    glUniform4uiv
+    glUniformBlockBinding
+    glUniformMatrix2x3fv
+    glUniformMatrix2x4fv
+    glUniformMatrix3x2fv
+    glUniformMatrix3x4fv
+    glUniformMatrix4x2fv
+    glUniformMatrix4x3fv
+    glUnmapBuffer
+    glVertexAttribDivisor
+    glVertexAttribI4i
+    glVertexAttribI4iv
+    glVertexAttribI4ui
+    glVertexAttribI4uiv
+    glVertexAttribIPointer
+    glWaitSync
+
+    ; OpenGL ES 3.1
+    glActiveShaderProgram
+    glBindImageTexture
+    glBindProgramPipeline
+    glBindVertexBuffer
+    glCreateShaderProgramv
+    glDeleteProgramPipelines
+    glDispatchCompute
+    glDispatchComputeIndirect
+    glDrawArraysIndirect
+    glDrawElementsIndirect
+    glFramebufferParameteri
+    glGenProgramPipelines
+    glGetBooleani_v
+    glGetFramebufferParameteriv
+    glGetMultisamplefv
+    glGetProgramInterfaceiv
+    glGetProgramPipelineInfoLog
+    glGetProgramPipelineiv
+    glGetProgramResourceIndex
+    glGetProgramResourceLocation
+    glGetProgramResourceName
+    glGetProgramResourceiv
+    glGetTexLevelParameterfv
+    glGetTexLevelParameteriv
+    glIsProgramPipeline
+    glMemoryBarrier
+    glMemoryBarrierByRegion
+    glProgramUniform1f
+    glProgramUniform1fv
+    glProgramUniform1i
+    glProgramUniform1iv
+    glProgramUniform1ui
+    glProgramUniform1uiv
+    glProgramUniform2f
+    glProgramUniform2fv
+    glProgramUniform2i
+    glProgramUniform2iv
+    glProgramUniform2ui
+    glProgramUniform2uiv
+    glProgramUniform3f
+    glProgramUniform3fv
+    glProgramUniform3i
+    glProgramUniform3iv
+    glProgramUniform3ui
+    glProgramUniform3uiv
+    glProgramUniform4f
+    glProgramUniform4fv
+    glProgramUniform4i
+    glProgramUniform4iv
+    glProgramUniform4ui
+    glProgramUniform4uiv
+    glProgramUniformMatrix2fv
+    glProgramUniformMatrix2x3fv
+    glProgramUniformMatrix2x4fv
+    glProgramUniformMatrix3fv
+    glProgramUniformMatrix3x2fv
+    glProgramUniformMatrix3x4fv
+    glProgramUniformMatrix4fv
+    glProgramUniformMatrix4x2fv
+    glProgramUniformMatrix4x3fv
+    glSampleMaski
+    glTexStorage2DMultisample
+    glUseProgramStages
+    glValidateProgramPipeline
+    glVertexAttribBinding
+    glVertexAttribFormat
+    glVertexAttribIFormat
+    glVertexBindingDivisor
+
+    ; OpenGL ES 1.0
+    glAlphaFunc
+    glAlphaFuncx
+    glClearColorx
+    glClearDepthx
+    glClientActiveTexture
+    glClipPlanef
+    glClipPlanex
+    glColor4f
+    glColor4ub
+    glColor4x
+    glColorPointer
+    glDepthRangex
+    glDisableClientState
+    glEnableClientState
+    glFogf
+    glFogfv
+    glFogx
+    glFogxv
+    glFrustumf
+    glFrustumx
+    glGetClipPlanef
+    glGetClipPlanex
+    glGetFixedv
+    glGetLightfv
+    glGetLightxv
+    glGetMaterialfv
+    glGetMaterialxv
+    glGetPointerv
+    glGetTexEnvfv
+    glGetTexEnviv
+    glGetTexEnvxv
+    glGetTexParameterxv
+    glLightModelf
+    glLightModelfv
+    glLightModelx
+    glLightModelxv
+    glLightf
+    glLightfv
+    glLightx
+    glLightxv
+    glLineWidthx
+    glLoadIdentity
+    glLoadMatrixf
+    glLoadMatrixx
+    glLogicOp
+    glMaterialf
+    glMaterialfv
+    glMaterialx
+    glMaterialxv
+    glMatrixMode
+    glMultMatrixf
+    glMultMatrixx
+    glMultiTexCoord4f
+    glMultiTexCoord4x
+    glNormal3f
+    glNormal3x
+    glNormalPointer
+    glOrthof
+    glOrthox
+    glPointParameterf
+    glPointParameterfv
+    glPointParameterx
+    glPointParameterxv
+    glPointSize
+    glPointSizex
+    glPolygonOffsetx
+    glPopMatrix
+    glPushMatrix
+    glRotatef
+    glRotatex
+    glSampleCoveragex
+    glScalef
+    glScalex
+    glShadeModel
+    glTexCoordPointer
+    glTexEnvf
+    glTexEnvfv
+    glTexEnvi
+    glTexEnviv
+    glTexEnvx
+    glTexEnvxv
+    glTexParameterx
+    glTexParameterxv
+    glTranslatef
+    glTranslatex
+    glVertexPointer
+
+    ; GL_ANGLE_copy_texture_3d
+    glCopySubTexture3DANGLE
+    glCopyTexture3DANGLE
+
+    ; GL_ANGLE_framebuffer_blit
+    glBlitFramebufferANGLE
+
+    ; GL_ANGLE_framebuffer_multisample
+    glRenderbufferStorageMultisampleANGLE
+
+    ; GL_ANGLE_instanced_arrays
+    glDrawArraysInstancedANGLE
+    glDrawElementsInstancedANGLE
+    glVertexAttribDivisorANGLE
+
+    ; GL_ANGLE_multi_draw
+    glMultiDrawArraysANGLE
+    glMultiDrawArraysInstancedANGLE
+    glMultiDrawElementsANGLE
+    glMultiDrawElementsInstancedANGLE
+
+    ; GL_ANGLE_provoking_vertex
+    glProvokingVertexANGLE
+
+    ; GL_ANGLE_request_extension
+    glRequestExtensionANGLE
+
+    ; GL_ANGLE_robust_client_memory
+    glCompressedTexImage2DRobustANGLE
+    glCompressedTexImage3DRobustANGLE
+    glCompressedTexSubImage2DRobustANGLE
+    glCompressedTexSubImage3DRobustANGLE
+    glGetActiveUniformBlockivRobustANGLE
+    glGetBooleani_vRobustANGLE
+    glGetBooleanvRobustANGLE
+    glGetBufferParameteri64vRobustANGLE
+    glGetBufferParameterivRobustANGLE
+    glGetBufferPointervRobustANGLE
+    glGetFloatvRobustANGLE
+    glGetFramebufferAttachmentParameterivRobustANGLE
+    glGetFramebufferParameterivRobustANGLE
+    glGetInteger64i_vRobustANGLE
+    glGetInteger64vRobustANGLE
+    glGetIntegeri_vRobustANGLE
+    glGetIntegervRobustANGLE
+    glGetInternalformativRobustANGLE
+    glGetMultisamplefvRobustANGLE
+    glGetPointervRobustANGLERobustANGLE
+    glGetProgramInterfaceivRobustANGLE
+    glGetProgramivRobustANGLE
+    glGetQueryObjecti64vRobustANGLE
+    glGetQueryObjectivRobustANGLE
+    glGetQueryObjectui64vRobustANGLE
+    glGetQueryObjectuivRobustANGLE
+    glGetQueryivRobustANGLE
+    glGetRenderbufferParameterivRobustANGLE
+    glGetSamplerParameterIivRobustANGLE
+    glGetSamplerParameterIuivRobustANGLE
+    glGetSamplerParameterfvRobustANGLE
+    glGetSamplerParameterivRobustANGLE
+    glGetShaderivRobustANGLE
+    glGetTexLevelParameterfvRobustANGLE
+    glGetTexLevelParameterivRobustANGLE
+    glGetTexParameterIivRobustANGLE
+    glGetTexParameterIuivRobustANGLE
+    glGetTexParameterfvRobustANGLE
+    glGetTexParameterivRobustANGLE
+    glGetUniformfvRobustANGLE
+    glGetUniformivRobustANGLE
+    glGetUniformuivRobustANGLE
+    glGetVertexAttribIivRobustANGLE
+    glGetVertexAttribIuivRobustANGLE
+    glGetVertexAttribPointervRobustANGLE
+    glGetVertexAttribfvRobustANGLE
+    glGetVertexAttribivRobustANGLE
+    glGetnUniformfvRobustANGLE
+    glGetnUniformivRobustANGLE
+    glGetnUniformuivRobustANGLE
+    glReadPixelsRobustANGLE
+    glReadnPixelsRobustANGLE
+    glSamplerParameterIivRobustANGLE
+    glSamplerParameterIuivRobustANGLE
+    glSamplerParameterfvRobustANGLE
+    glSamplerParameterivRobustANGLE
+    glTexImage2DRobustANGLE
+    glTexImage3DRobustANGLE
+    glTexParameterIivRobustANGLE
+    glTexParameterIuivRobustANGLE
+    glTexParameterfvRobustANGLE
+    glTexParameterivRobustANGLE
+    glTexSubImage2DRobustANGLE
+    glTexSubImage3DRobustANGLE
+
+    ; GL_ANGLE_texture_external_update
+    glInvalidateTextureANGLE
+    glTexImage2DExternalANGLE
+
+    ; GL_ANGLE_texture_multisample
+    glGetMultisamplefvANGLE
+    glGetTexLevelParameterfvANGLE
+    glGetTexLevelParameterivANGLE
+    glSampleMaskiANGLE
+    glTexStorage2DMultisampleANGLE
+
+    ; GL_ANGLE_translated_shader_source
+    glGetTranslatedShaderSourceANGLE
+
+    ; GL_CHROMIUM_bind_uniform_location
+    glBindUniformLocationCHROMIUM
+
+    ; GL_CHROMIUM_copy_compressed_texture
+    glCompressedCopyTextureCHROMIUM
+
+    ; GL_CHROMIUM_copy_texture
+    glCopySubTextureCHROMIUM
+    glCopyTextureCHROMIUM
+
+    ; GL_CHROMIUM_framebuffer_mixed_samples
+    glCoverageModulationCHROMIUM
+    glMatrixLoadIdentityCHROMIUM
+    glMatrixLoadfCHROMIUM
+
+    ; GL_CHROMIUM_lose_context
+    glLoseContextCHROMIUM
+
+    ; GL_CHROMIUM_path_rendering
+    glBindFragmentInputLocationCHROMIUM
+    glCoverFillPathCHROMIUM
+    glCoverFillPathInstancedCHROMIUM
+    glCoverStrokePathCHROMIUM
+    glCoverStrokePathInstancedCHROMIUM
+    glDeletePathsCHROMIUM
+    glGenPathsCHROMIUM
+    glGetPathParameterfvCHROMIUM
+    glGetPathParameterivCHROMIUM
+    glIsPathCHROMIUM
+    glPathCommandsCHROMIUM
+    glPathParameterfCHROMIUM
+    glPathParameteriCHROMIUM
+    glPathStencilFuncCHROMIUM
+    glProgramPathFragmentInputGenCHROMIUM
+    glStencilFillPathCHROMIUM
+    glStencilFillPathInstancedCHROMIUM
+    glStencilStrokePathCHROMIUM
+    glStencilStrokePathInstancedCHROMIUM
+    glStencilThenCoverFillPathCHROMIUM
+    glStencilThenCoverFillPathInstancedCHROMIUM
+    glStencilThenCoverStrokePathCHROMIUM
+    glStencilThenCoverStrokePathInstancedCHROMIUM
+
+    ; GL_EXT_blend_func_extended
+    glBindFragDataLocationEXT
+    glBindFragDataLocationIndexedEXT
+    glGetFragDataIndexEXT
+    glGetProgramResourceLocationIndexEXT
+
+    ; GL_EXT_debug_marker
+    glInsertEventMarkerEXT
+    glPopGroupMarkerEXT
+    glPushGroupMarkerEXT
+
+    ; GL_EXT_discard_framebuffer
+    glDiscardFramebufferEXT
+
+    ; GL_EXT_disjoint_timer_query
+    glBeginQueryEXT
+    glDeleteQueriesEXT
+    glEndQueryEXT
+    glGenQueriesEXT
+    glGetQueryObjecti64vEXT
+    glGetQueryObjectivEXT
+    glGetQueryObjectui64vEXT
+    glGetQueryObjectuivEXT
+    glGetQueryivEXT
+    glIsQueryEXT
+    glQueryCounterEXT
+
+    ; GL_EXT_draw_buffers
+    glDrawBuffersEXT
+
+    ; GL_EXT_geometry_shader
+    glFramebufferTextureEXT
+
+    ; GL_EXT_instanced_arrays
+    glDrawArraysInstancedEXT
+    glDrawElementsInstancedEXT
+    glVertexAttribDivisorEXT
+
+    ; GL_EXT_map_buffer_range
+    glFlushMappedBufferRangeEXT
+    glMapBufferRangeEXT
+
+    ; GL_EXT_memory_object
+    glBufferStorageMemEXT
+    glCreateMemoryObjectsEXT
+    glDeleteMemoryObjectsEXT
+    glGetMemoryObjectParameterivEXT
+    glGetUnsignedBytei_vEXT
+    glGetUnsignedBytevEXT
+    glIsMemoryObjectEXT
+    glMemoryObjectParameterivEXT
+    glTexStorageMem2DEXT
+    glTexStorageMem2DMultisampleEXT
+    glTexStorageMem3DEXT
+    glTexStorageMem3DMultisampleEXT
+
+    ; GL_EXT_memory_object_fd
+    glImportMemoryFdEXT
+
+    ; GL_EXT_occlusion_query_boolean
+
+    ; GL_EXT_robustness
+    glGetGraphicsResetStatusEXT
+    glGetnUniformfvEXT
+    glGetnUniformivEXT
+    glReadnPixelsEXT
+
+    ; GL_EXT_semaphore
+    glDeleteSemaphoresEXT
+    glGenSemaphoresEXT
+    glGetSemaphoreParameterui64vEXT
+    glIsSemaphoreEXT
+    glSemaphoreParameterui64vEXT
+    glSignalSemaphoreEXT
+    glWaitSemaphoreEXT
+
+    ; GL_EXT_semaphore_fd
+    glImportSemaphoreFdEXT
+
+    ; GL_EXT_texture_storage
+    glTexStorage1DEXT
+    glTexStorage2DEXT
+    glTexStorage3DEXT
+
+    ; GL_KHR_debug
+    glDebugMessageCallbackKHR
+    glDebugMessageControlKHR
+    glDebugMessageInsertKHR
+    glGetDebugMessageLogKHR
+    glGetObjectLabelKHR
+    glGetObjectPtrLabelKHR
+    glGetPointervKHR
+    glObjectLabelKHR
+    glObjectPtrLabelKHR
+    glPopDebugGroupKHR
+    glPushDebugGroupKHR
+
+    ; GL_KHR_parallel_shader_compile
+    glMaxShaderCompilerThreadsKHR
+
+    ; GL_NV_fence
+    glDeleteFencesNV
+    glFinishFenceNV
+    glGenFencesNV
+    glGetFenceivNV
+    glIsFenceNV
+    glSetFenceNV
+    glTestFenceNV
+
+    ; GL_OES_EGL_image
+    glEGLImageTargetRenderbufferStorageOES
+    glEGLImageTargetTexture2DOES
+
+    ; GL_OES_draw_texture
+    glDrawTexfOES
+    glDrawTexfvOES
+    glDrawTexiOES
+    glDrawTexivOES
+    glDrawTexsOES
+    glDrawTexsvOES
+    glDrawTexxOES
+    glDrawTexxvOES
+
+    ; GL_OES_framebuffer_object
+    glBindFramebufferOES
+    glBindRenderbufferOES
+    glCheckFramebufferStatusOES
+    glDeleteFramebuffersOES
+    glDeleteRenderbuffersOES
+    glFramebufferRenderbufferOES
+    glFramebufferTexture2DOES
+    glGenFramebuffersOES
+    glGenRenderbuffersOES
+    glGenerateMipmapOES
+    glGetFramebufferAttachmentParameterivOES
+    glGetRenderbufferParameterivOES
+    glIsFramebufferOES
+    glIsRenderbufferOES
+    glRenderbufferStorageOES
+
+    ; GL_OES_get_program_binary
+    glGetProgramBinaryOES
+    glProgramBinaryOES
+
+    ; GL_OES_mapbuffer
+    glGetBufferPointervOES
+    glMapBufferOES
+    glUnmapBufferOES
+
+    ; GL_OES_matrix_palette
+    glCurrentPaletteMatrixOES
+    glLoadPaletteFromModelViewMatrixOES
+    glMatrixIndexPointerOES
+    glWeightPointerOES
+
+    ; GL_OES_point_size_array
+    glPointSizePointerOES
+
+    ; GL_OES_query_matrix
+    glQueryMatrixxOES
+
+    ; GL_OES_texture_3D
+    glCompressedTexImage3DOES
+    glCompressedTexSubImage3DOES
+    glCopyTexSubImage3DOES
+    glFramebufferTexture3DOES
+    glTexImage3DOES
+    glTexSubImage3DOES
+
+    ; GL_OES_texture_border_clamp
+    glGetSamplerParameterIivOES
+    glGetSamplerParameterIuivOES
+    glGetTexParameterIivOES
+    glGetTexParameterIuivOES
+    glSamplerParameterIivOES
+    glSamplerParameterIuivOES
+    glTexParameterIivOES
+    glTexParameterIuivOES
+
+    ; GL_OES_texture_cube_map
+    glGetTexGenfvOES
+    glGetTexGenivOES
+    glGetTexGenxvOES
+    glTexGenfOES
+    glTexGenfvOES
+    glTexGeniOES
+    glTexGenivOES
+    glTexGenxOES
+    glTexGenxvOES
+
+    ; GL_OES_texture_storage_multisample_2d_array
+    glTexStorage3DMultisampleOES
+
+    ; GL_OES_vertex_array_object
+    glBindVertexArrayOES
+    glDeleteVertexArraysOES
+    glGenVertexArraysOES
+    glIsVertexArrayOES
+
+    ; GL_OVR_multiview
+    glFramebufferTextureMultiviewOVR
+
+    ; GL_OVR_multiview2
+
+    ; EGL_ANGLE_explicit_context
+    glActiveShaderProgramContextANGLE
+    glActiveTextureContextANGLE
+    glAlphaFuncContextANGLE
+    glAlphaFuncxContextANGLE
+    glAttachShaderContextANGLE
+    glBeginQueryContextANGLE
+    glBeginQueryEXTContextANGLE
+    glBeginTransformFeedbackContextANGLE
+    glBindAttribLocationContextANGLE
+    glBindBufferContextANGLE
+    glBindBufferBaseContextANGLE
+    glBindBufferRangeContextANGLE
+    glBindFragDataLocationEXTContextANGLE
+    glBindFragDataLocationIndexedEXTContextANGLE
+    glBindFragmentInputLocationCHROMIUMContextANGLE
+    glBindFramebufferContextANGLE
+    glBindFramebufferOESContextANGLE
+    glBindImageTextureContextANGLE
+    glBindProgramPipelineContextANGLE
+    glBindRenderbufferContextANGLE
+    glBindRenderbufferOESContextANGLE
+    glBindSamplerContextANGLE
+    glBindTextureContextANGLE
+    glBindTransformFeedbackContextANGLE
+    glBindUniformLocationCHROMIUMContextANGLE
+    glBindVertexArrayContextANGLE
+    glBindVertexArrayOESContextANGLE
+    glBindVertexBufferContextANGLE
+    glBlendColorContextANGLE
+    glBlendEquationContextANGLE
+    glBlendEquationSeparateContextANGLE
+    glBlendFuncContextANGLE
+    glBlendFuncSeparateContextANGLE
+    glBlitFramebufferContextANGLE
+    glBlitFramebufferANGLEContextANGLE
+    glBufferDataContextANGLE
+    glBufferStorageMemEXTContextANGLE
+    glBufferSubDataContextANGLE
+    glCheckFramebufferStatusContextANGLE
+    glCheckFramebufferStatusOESContextANGLE
+    glClearContextANGLE
+    glClearBufferfiContextANGLE
+    glClearBufferfvContextANGLE
+    glClearBufferivContextANGLE
+    glClearBufferuivContextANGLE
+    glClearColorContextANGLE
+    glClearColorxContextANGLE
+    glClearDepthfContextANGLE
+    glClearDepthxContextANGLE
+    glClearStencilContextANGLE
+    glClientActiveTextureContextANGLE
+    glClientWaitSyncContextANGLE
+    glClipPlanefContextANGLE
+    glClipPlanexContextANGLE
+    glColor4fContextANGLE
+    glColor4ubContextANGLE
+    glColor4xContextANGLE
+    glColorMaskContextANGLE
+    glColorPointerContextANGLE
+    glCompileShaderContextANGLE
+    glCompressedCopyTextureCHROMIUMContextANGLE
+    glCompressedTexImage2DContextANGLE
+    glCompressedTexImage2DRobustANGLEContextANGLE
+    glCompressedTexImage3DContextANGLE
+    glCompressedTexImage3DOESContextANGLE
+    glCompressedTexImage3DRobustANGLEContextANGLE
+    glCompressedTexSubImage2DContextANGLE
+    glCompressedTexSubImage2DRobustANGLEContextANGLE
+    glCompressedTexSubImage3DContextANGLE
+    glCompressedTexSubImage3DOESContextANGLE
+    glCompressedTexSubImage3DRobustANGLEContextANGLE
+    glCopyBufferSubDataContextANGLE
+    glCopySubTexture3DANGLEContextANGLE
+    glCopySubTextureCHROMIUMContextANGLE
+    glCopyTexImage2DContextANGLE
+    glCopyTexSubImage2DContextANGLE
+    glCopyTexSubImage3DContextANGLE
+    glCopyTexSubImage3DOESContextANGLE
+    glCopyTexture3DANGLEContextANGLE
+    glCopyTextureCHROMIUMContextANGLE
+    glCoverFillPathCHROMIUMContextANGLE
+    glCoverFillPathInstancedCHROMIUMContextANGLE
+    glCoverStrokePathCHROMIUMContextANGLE
+    glCoverStrokePathInstancedCHROMIUMContextANGLE
+    glCoverageModulationCHROMIUMContextANGLE
+    glCreateMemoryObjectsEXTContextANGLE
+    glCreateProgramContextANGLE
+    glCreateShaderContextANGLE
+    glCreateShaderProgramvContextANGLE
+    glCullFaceContextANGLE
+    glCurrentPaletteMatrixOESContextANGLE
+    glDebugMessageCallbackKHRContextANGLE
+    glDebugMessageControlKHRContextANGLE
+    glDebugMessageInsertKHRContextANGLE
+    glDeleteBuffersContextANGLE
+    glDeleteFencesNVContextANGLE
+    glDeleteFramebuffersContextANGLE
+    glDeleteFramebuffersOESContextANGLE
+    glDeleteMemoryObjectsEXTContextANGLE
+    glDeletePathsCHROMIUMContextANGLE
+    glDeleteProgramContextANGLE
+    glDeleteProgramPipelinesContextANGLE
+    glDeleteQueriesContextANGLE
+    glDeleteQueriesEXTContextANGLE
+    glDeleteRenderbuffersContextANGLE
+    glDeleteRenderbuffersOESContextANGLE
+    glDeleteSamplersContextANGLE
+    glDeleteSemaphoresEXTContextANGLE
+    glDeleteShaderContextANGLE
+    glDeleteSyncContextANGLE
+    glDeleteTexturesContextANGLE
+    glDeleteTransformFeedbacksContextANGLE
+    glDeleteVertexArraysContextANGLE
+    glDeleteVertexArraysOESContextANGLE
+    glDepthFuncContextANGLE
+    glDepthMaskContextANGLE
+    glDepthRangefContextANGLE
+    glDepthRangexContextANGLE
+    glDetachShaderContextANGLE
+    glDisableContextANGLE
+    glDisableClientStateContextANGLE
+    glDisableVertexAttribArrayContextANGLE
+    glDiscardFramebufferEXTContextANGLE
+    glDispatchComputeContextANGLE
+    glDispatchComputeIndirectContextANGLE
+    glDrawArraysContextANGLE
+    glDrawArraysIndirectContextANGLE
+    glDrawArraysInstancedContextANGLE
+    glDrawArraysInstancedANGLEContextANGLE
+    glDrawArraysInstancedEXTContextANGLE
+    glDrawBuffersContextANGLE
+    glDrawBuffersEXTContextANGLE
+    glDrawElementsContextANGLE
+    glDrawElementsIndirectContextANGLE
+    glDrawElementsInstancedContextANGLE
+    glDrawElementsInstancedANGLEContextANGLE
+    glDrawElementsInstancedEXTContextANGLE
+    glDrawRangeElementsContextANGLE
+    glDrawTexfOESContextANGLE
+    glDrawTexfvOESContextANGLE
+    glDrawTexiOESContextANGLE
+    glDrawTexivOESContextANGLE
+    glDrawTexsOESContextANGLE
+    glDrawTexsvOESContextANGLE
+    glDrawTexxOESContextANGLE
+    glDrawTexxvOESContextANGLE
+    glEGLImageTargetRenderbufferStorageOESContextANGLE
+    glEGLImageTargetTexture2DOESContextANGLE
+    glEnableContextANGLE
+    glEnableClientStateContextANGLE
+    glEnableVertexAttribArrayContextANGLE
+    glEndQueryContextANGLE
+    glEndQueryEXTContextANGLE
+    glEndTransformFeedbackContextANGLE
+    glFenceSyncContextANGLE
+    glFinishContextANGLE
+    glFinishFenceNVContextANGLE
+    glFlushContextANGLE
+    glFlushMappedBufferRangeContextANGLE
+    glFlushMappedBufferRangeEXTContextANGLE
+    glFogfContextANGLE
+    glFogfvContextANGLE
+    glFogxContextANGLE
+    glFogxvContextANGLE
+    glFramebufferParameteriContextANGLE
+    glFramebufferRenderbufferContextANGLE
+    glFramebufferRenderbufferOESContextANGLE
+    glFramebufferTexture2DContextANGLE
+    glFramebufferTexture2DOESContextANGLE
+    glFramebufferTexture3DOESContextANGLE
+    glFramebufferTextureEXTContextANGLE
+    glFramebufferTextureLayerContextANGLE
+    glFramebufferTextureMultiviewOVRContextANGLE
+    glFrontFaceContextANGLE
+    glFrustumfContextANGLE
+    glFrustumxContextANGLE
+    glGenBuffersContextANGLE
+    glGenFencesNVContextANGLE
+    glGenFramebuffersContextANGLE
+    glGenFramebuffersOESContextANGLE
+    glGenPathsCHROMIUMContextANGLE
+    glGenProgramPipelinesContextANGLE
+    glGenQueriesContextANGLE
+    glGenQueriesEXTContextANGLE
+    glGenRenderbuffersContextANGLE
+    glGenRenderbuffersOESContextANGLE
+    glGenSamplersContextANGLE
+    glGenSemaphoresEXTContextANGLE
+    glGenTexturesContextANGLE
+    glGenTransformFeedbacksContextANGLE
+    glGenVertexArraysContextANGLE
+    glGenVertexArraysOESContextANGLE
+    glGenerateMipmapContextANGLE
+    glGenerateMipmapOESContextANGLE
+    glGetActiveAttribContextANGLE
+    glGetActiveUniformContextANGLE
+    glGetActiveUniformBlockNameContextANGLE
+    glGetActiveUniformBlockivContextANGLE
+    glGetActiveUniformBlockivRobustANGLEContextANGLE
+    glGetActiveUniformsivContextANGLE
+    glGetAttachedShadersContextANGLE
+    glGetAttribLocationContextANGLE
+    glGetBooleani_vContextANGLE
+    glGetBooleani_vRobustANGLEContextANGLE
+    glGetBooleanvContextANGLE
+    glGetBooleanvRobustANGLEContextANGLE
+    glGetBufferParameteri64vContextANGLE
+    glGetBufferParameteri64vRobustANGLEContextANGLE
+    glGetBufferParameterivContextANGLE
+    glGetBufferParameterivRobustANGLEContextANGLE
+    glGetBufferPointervContextANGLE
+    glGetBufferPointervOESContextANGLE
+    glGetBufferPointervRobustANGLEContextANGLE
+    glGetClipPlanefContextANGLE
+    glGetClipPlanexContextANGLE
+    glGetDebugMessageLogKHRContextANGLE
+    glGetErrorContextANGLE
+    glGetFenceivNVContextANGLE
+    glGetFixedvContextANGLE
+    glGetFloatvContextANGLE
+    glGetFloatvRobustANGLEContextANGLE
+    glGetFragDataIndexEXTContextANGLE
+    glGetFragDataLocationContextANGLE
+    glGetFramebufferAttachmentParameterivContextANGLE
+    glGetFramebufferAttachmentParameterivOESContextANGLE
+    glGetFramebufferAttachmentParameterivRobustANGLEContextANGLE
+    glGetFramebufferParameterivContextANGLE
+    glGetFramebufferParameterivRobustANGLEContextANGLE
+    glGetGraphicsResetStatusEXTContextANGLE
+    glGetInteger64i_vContextANGLE
+    glGetInteger64i_vRobustANGLEContextANGLE
+    glGetInteger64vContextANGLE
+    glGetInteger64vRobustANGLEContextANGLE
+    glGetIntegeri_vContextANGLE
+    glGetIntegeri_vRobustANGLEContextANGLE
+    glGetIntegervContextANGLE
+    glGetIntegervRobustANGLEContextANGLE
+    glGetInternalformativContextANGLE
+    glGetInternalformativRobustANGLEContextANGLE
+    glGetLightfvContextANGLE
+    glGetLightxvContextANGLE
+    glGetMaterialfvContextANGLE
+    glGetMaterialxvContextANGLE
+    glGetMemoryObjectParameterivEXTContextANGLE
+    glGetMultisamplefvContextANGLE
+    glGetMultisamplefvANGLEContextANGLE
+    glGetMultisamplefvRobustANGLEContextANGLE
+    glGetObjectLabelKHRContextANGLE
+    glGetObjectPtrLabelKHRContextANGLE
+    glGetPathParameterfvCHROMIUMContextANGLE
+    glGetPathParameterivCHROMIUMContextANGLE
+    glGetPointervContextANGLE
+    glGetPointervKHRContextANGLE
+    glGetPointervRobustANGLERobustANGLEContextANGLE
+    glGetProgramBinaryContextANGLE
+    glGetProgramBinaryOESContextANGLE
+    glGetProgramInfoLogContextANGLE
+    glGetProgramInterfaceivContextANGLE
+    glGetProgramInterfaceivRobustANGLEContextANGLE
+    glGetProgramPipelineInfoLogContextANGLE
+    glGetProgramPipelineivContextANGLE
+    glGetProgramResourceIndexContextANGLE
+    glGetProgramResourceLocationContextANGLE
+    glGetProgramResourceLocationIndexEXTContextANGLE
+    glGetProgramResourceNameContextANGLE
+    glGetProgramResourceivContextANGLE
+    glGetProgramivContextANGLE
+    glGetProgramivRobustANGLEContextANGLE
+    glGetQueryObjecti64vEXTContextANGLE
+    glGetQueryObjecti64vRobustANGLEContextANGLE
+    glGetQueryObjectivEXTContextANGLE
+    glGetQueryObjectivRobustANGLEContextANGLE
+    glGetQueryObjectui64vEXTContextANGLE
+    glGetQueryObjectui64vRobustANGLEContextANGLE
+    glGetQueryObjectuivContextANGLE
+    glGetQueryObjectuivEXTContextANGLE
+    glGetQueryObjectuivRobustANGLEContextANGLE
+    glGetQueryivContextANGLE
+    glGetQueryivEXTContextANGLE
+    glGetQueryivRobustANGLEContextANGLE
+    glGetRenderbufferParameterivContextANGLE
+    glGetRenderbufferParameterivOESContextANGLE
+    glGetRenderbufferParameterivRobustANGLEContextANGLE
+    glGetSamplerParameterIivOESContextANGLE
+    glGetSamplerParameterIivRobustANGLEContextANGLE
+    glGetSamplerParameterIuivOESContextANGLE
+    glGetSamplerParameterIuivRobustANGLEContextANGLE
+    glGetSamplerParameterfvContextANGLE
+    glGetSamplerParameterfvRobustANGLEContextANGLE
+    glGetSamplerParameterivContextANGLE
+    glGetSamplerParameterivRobustANGLEContextANGLE
+    glGetSemaphoreParameterui64vEXTContextANGLE
+    glGetShaderInfoLogContextANGLE
+    glGetShaderPrecisionFormatContextANGLE
+    glGetShaderSourceContextANGLE
+    glGetShaderivContextANGLE
+    glGetShaderivRobustANGLEContextANGLE
+    glGetStringContextANGLE
+    glGetStringiContextANGLE
+    glGetSyncivContextANGLE
+    glGetTexEnvfvContextANGLE
+    glGetTexEnvivContextANGLE
+    glGetTexEnvxvContextANGLE
+    glGetTexGenfvOESContextANGLE
+    glGetTexGenivOESContextANGLE
+    glGetTexGenxvOESContextANGLE
+    glGetTexLevelParameterfvContextANGLE
+    glGetTexLevelParameterfvANGLEContextANGLE
+    glGetTexLevelParameterfvRobustANGLEContextANGLE
+    glGetTexLevelParameterivContextANGLE
+    glGetTexLevelParameterivANGLEContextANGLE
+    glGetTexLevelParameterivRobustANGLEContextANGLE
+    glGetTexParameterIivOESContextANGLE
+    glGetTexParameterIivRobustANGLEContextANGLE
+    glGetTexParameterIuivOESContextANGLE
+    glGetTexParameterIuivRobustANGLEContextANGLE
+    glGetTexParameterfvContextANGLE
+    glGetTexParameterfvRobustANGLEContextANGLE
+    glGetTexParameterivContextANGLE
+    glGetTexParameterivRobustANGLEContextANGLE
+    glGetTexParameterxvContextANGLE
+    glGetTransformFeedbackVaryingContextANGLE
+    glGetTranslatedShaderSourceANGLEContextANGLE
+    glGetUniformBlockIndexContextANGLE
+    glGetUniformIndicesContextANGLE
+    glGetUniformLocationContextANGLE
+    glGetUniformfvContextANGLE
+    glGetUniformfvRobustANGLEContextANGLE
+    glGetUniformivContextANGLE
+    glGetUniformivRobustANGLEContextANGLE
+    glGetUniformuivContextANGLE
+    glGetUniformuivRobustANGLEContextANGLE
+    glGetUnsignedBytei_vEXTContextANGLE
+    glGetUnsignedBytevEXTContextANGLE
+    glGetVertexAttribIivContextANGLE
+    glGetVertexAttribIivRobustANGLEContextANGLE
+    glGetVertexAttribIuivContextANGLE
+    glGetVertexAttribIuivRobustANGLEContextANGLE
+    glGetVertexAttribPointervContextANGLE
+    glGetVertexAttribPointervRobustANGLEContextANGLE
+    glGetVertexAttribfvContextANGLE
+    glGetVertexAttribfvRobustANGLEContextANGLE
+    glGetVertexAttribivContextANGLE
+    glGetVertexAttribivRobustANGLEContextANGLE
+    glGetnUniformfvEXTContextANGLE
+    glGetnUniformfvRobustANGLEContextANGLE
+    glGetnUniformivEXTContextANGLE
+    glGetnUniformivRobustANGLEContextANGLE
+    glGetnUniformuivRobustANGLEContextANGLE
+    glHintContextANGLE
+    glImportMemoryFdEXTContextANGLE
+    glImportSemaphoreFdEXTContextANGLE
+    glInsertEventMarkerEXTContextANGLE
+    glInvalidateFramebufferContextANGLE
+    glInvalidateSubFramebufferContextANGLE
+    glInvalidateTextureANGLEContextANGLE
+    glIsBufferContextANGLE
+    glIsEnabledContextANGLE
+    glIsFenceNVContextANGLE
+    glIsFramebufferContextANGLE
+    glIsFramebufferOESContextANGLE
+    glIsMemoryObjectEXTContextANGLE
+    glIsPathCHROMIUMContextANGLE
+    glIsProgramContextANGLE
+    glIsProgramPipelineContextANGLE
+    glIsQueryContextANGLE
+    glIsQueryEXTContextANGLE
+    glIsRenderbufferContextANGLE
+    glIsRenderbufferOESContextANGLE
+    glIsSamplerContextANGLE
+    glIsSemaphoreEXTContextANGLE
+    glIsShaderContextANGLE
+    glIsSyncContextANGLE
+    glIsTextureContextANGLE
+    glIsTransformFeedbackContextANGLE
+    glIsVertexArrayContextANGLE
+    glIsVertexArrayOESContextANGLE
+    glLightModelfContextANGLE
+    glLightModelfvContextANGLE
+    glLightModelxContextANGLE
+    glLightModelxvContextANGLE
+    glLightfContextANGLE
+    glLightfvContextANGLE
+    glLightxContextANGLE
+    glLightxvContextANGLE
+    glLineWidthContextANGLE
+    glLineWidthxContextANGLE
+    glLinkProgramContextANGLE
+    glLoadIdentityContextANGLE
+    glLoadMatrixfContextANGLE
+    glLoadMatrixxContextANGLE
+    glLoadPaletteFromModelViewMatrixOESContextANGLE
+    glLogicOpContextANGLE
+    glLoseContextCHROMIUMContextANGLE
+    glMapBufferOESContextANGLE
+    glMapBufferRangeContextANGLE
+    glMapBufferRangeEXTContextANGLE
+    glMaterialfContextANGLE
+    glMaterialfvContextANGLE
+    glMaterialxContextANGLE
+    glMaterialxvContextANGLE
+    glMatrixIndexPointerOESContextANGLE
+    glMatrixLoadIdentityCHROMIUMContextANGLE
+    glMatrixLoadfCHROMIUMContextANGLE
+    glMatrixModeContextANGLE
+    glMaxShaderCompilerThreadsKHRContextANGLE
+    glMemoryBarrierContextANGLE
+    glMemoryBarrierByRegionContextANGLE
+    glMemoryObjectParameterivEXTContextANGLE
+    glMultMatrixfContextANGLE
+    glMultMatrixxContextANGLE
+    glMultiDrawArraysANGLEContextANGLE
+    glMultiDrawArraysInstancedANGLEContextANGLE
+    glMultiDrawElementsANGLEContextANGLE
+    glMultiDrawElementsInstancedANGLEContextANGLE
+    glMultiTexCoord4fContextANGLE
+    glMultiTexCoord4xContextANGLE
+    glNormal3fContextANGLE
+    glNormal3xContextANGLE
+    glNormalPointerContextANGLE
+    glObjectLabelKHRContextANGLE
+    glObjectPtrLabelKHRContextANGLE
+    glOrthofContextANGLE
+    glOrthoxContextANGLE
+    glPathCommandsCHROMIUMContextANGLE
+    glPathParameterfCHROMIUMContextANGLE
+    glPathParameteriCHROMIUMContextANGLE
+    glPathStencilFuncCHROMIUMContextANGLE
+    glPauseTransformFeedbackContextANGLE
+    glPixelStoreiContextANGLE
+    glPointParameterfContextANGLE
+    glPointParameterfvContextANGLE
+    glPointParameterxContextANGLE
+    glPointParameterxvContextANGLE
+    glPointSizeContextANGLE
+    glPointSizePointerOESContextANGLE
+    glPointSizexContextANGLE
+    glPolygonOffsetContextANGLE
+    glPolygonOffsetxContextANGLE
+    glPopDebugGroupKHRContextANGLE
+    glPopGroupMarkerEXTContextANGLE
+    glPopMatrixContextANGLE
+    glProgramBinaryContextANGLE
+    glProgramBinaryOESContextANGLE
+    glProgramParameteriContextANGLE
+    glProgramPathFragmentInputGenCHROMIUMContextANGLE
+    glProgramUniform1fContextANGLE
+    glProgramUniform1fvContextANGLE
+    glProgramUniform1iContextANGLE
+    glProgramUniform1ivContextANGLE
+    glProgramUniform1uiContextANGLE
+    glProgramUniform1uivContextANGLE
+    glProgramUniform2fContextANGLE
+    glProgramUniform2fvContextANGLE
+    glProgramUniform2iContextANGLE
+    glProgramUniform2ivContextANGLE
+    glProgramUniform2uiContextANGLE
+    glProgramUniform2uivContextANGLE
+    glProgramUniform3fContextANGLE
+    glProgramUniform3fvContextANGLE
+    glProgramUniform3iContextANGLE
+    glProgramUniform3ivContextANGLE
+    glProgramUniform3uiContextANGLE
+    glProgramUniform3uivContextANGLE
+    glProgramUniform4fContextANGLE
+    glProgramUniform4fvContextANGLE
+    glProgramUniform4iContextANGLE
+    glProgramUniform4ivContextANGLE
+    glProgramUniform4uiContextANGLE
+    glProgramUniform4uivContextANGLE
+    glProgramUniformMatrix2fvContextANGLE
+    glProgramUniformMatrix2x3fvContextANGLE
+    glProgramUniformMatrix2x4fvContextANGLE
+    glProgramUniformMatrix3fvContextANGLE
+    glProgramUniformMatrix3x2fvContextANGLE
+    glProgramUniformMatrix3x4fvContextANGLE
+    glProgramUniformMatrix4fvContextANGLE
+    glProgramUniformMatrix4x2fvContextANGLE
+    glProgramUniformMatrix4x3fvContextANGLE
+    glProvokingVertexANGLEContextANGLE
+    glPushDebugGroupKHRContextANGLE
+    glPushGroupMarkerEXTContextANGLE
+    glPushMatrixContextANGLE
+    glQueryCounterEXTContextANGLE
+    glQueryMatrixxOESContextANGLE
+    glReadBufferContextANGLE
+    glReadPixelsContextANGLE
+    glReadPixelsRobustANGLEContextANGLE
+    glReadnPixelsEXTContextANGLE
+    glReadnPixelsRobustANGLEContextANGLE
+    glReleaseShaderCompilerContextANGLE
+    glRenderbufferStorageContextANGLE
+    glRenderbufferStorageMultisampleContextANGLE
+    glRenderbufferStorageMultisampleANGLEContextANGLE
+    glRenderbufferStorageOESContextANGLE
+    glRequestExtensionANGLEContextANGLE
+    glResumeTransformFeedbackContextANGLE
+    glRotatefContextANGLE
+    glRotatexContextANGLE
+    glSampleCoverageContextANGLE
+    glSampleCoveragexContextANGLE
+    glSampleMaskiContextANGLE
+    glSampleMaskiANGLEContextANGLE
+    glSamplerParameterIivOESContextANGLE
+    glSamplerParameterIivRobustANGLEContextANGLE
+    glSamplerParameterIuivOESContextANGLE
+    glSamplerParameterIuivRobustANGLEContextANGLE
+    glSamplerParameterfContextANGLE
+    glSamplerParameterfvContextANGLE
+    glSamplerParameterfvRobustANGLEContextANGLE
+    glSamplerParameteriContextANGLE
+    glSamplerParameterivContextANGLE
+    glSamplerParameterivRobustANGLEContextANGLE
+    glScalefContextANGLE
+    glScalexContextANGLE
+    glScissorContextANGLE
+    glSemaphoreParameterui64vEXTContextANGLE
+    glSetFenceNVContextANGLE
+    glShadeModelContextANGLE
+    glShaderBinaryContextANGLE
+    glShaderSourceContextANGLE
+    glSignalSemaphoreEXTContextANGLE
+    glStencilFillPathCHROMIUMContextANGLE
+    glStencilFillPathInstancedCHROMIUMContextANGLE
+    glStencilFuncContextANGLE
+    glStencilFuncSeparateContextANGLE
+    glStencilMaskContextANGLE
+    glStencilMaskSeparateContextANGLE
+    glStencilOpContextANGLE
+    glStencilOpSeparateContextANGLE
+    glStencilStrokePathCHROMIUMContextANGLE
+    glStencilStrokePathInstancedCHROMIUMContextANGLE
+    glStencilThenCoverFillPathCHROMIUMContextANGLE
+    glStencilThenCoverFillPathInstancedCHROMIUMContextANGLE
+    glStencilThenCoverStrokePathCHROMIUMContextANGLE
+    glStencilThenCoverStrokePathInstancedCHROMIUMContextANGLE
+    glTestFenceNVContextANGLE
+    glTexCoordPointerContextANGLE
+    glTexEnvfContextANGLE
+    glTexEnvfvContextANGLE
+    glTexEnviContextANGLE
+    glTexEnvivContextANGLE
+    glTexEnvxContextANGLE
+    glTexEnvxvContextANGLE
+    glTexGenfOESContextANGLE
+    glTexGenfvOESContextANGLE
+    glTexGeniOESContextANGLE
+    glTexGenivOESContextANGLE
+    glTexGenxOESContextANGLE
+    glTexGenxvOESContextANGLE
+    glTexImage2DContextANGLE
+    glTexImage2DExternalANGLEContextANGLE
+    glTexImage2DRobustANGLEContextANGLE
+    glTexImage3DContextANGLE
+    glTexImage3DOESContextANGLE
+    glTexImage3DRobustANGLEContextANGLE
+    glTexParameterIivOESContextANGLE
+    glTexParameterIivRobustANGLEContextANGLE
+    glTexParameterIuivOESContextANGLE
+    glTexParameterIuivRobustANGLEContextANGLE
+    glTexParameterfContextANGLE
+    glTexParameterfvContextANGLE
+    glTexParameterfvRobustANGLEContextANGLE
+    glTexParameteriContextANGLE
+    glTexParameterivContextANGLE
+    glTexParameterivRobustANGLEContextANGLE
+    glTexParameterxContextANGLE
+    glTexParameterxvContextANGLE
+    glTexStorage1DEXTContextANGLE
+    glTexStorage2DContextANGLE
+    glTexStorage2DEXTContextANGLE
+    glTexStorage2DMultisampleContextANGLE
+    glTexStorage2DMultisampleANGLEContextANGLE
+    glTexStorage3DContextANGLE
+    glTexStorage3DEXTContextANGLE
+    glTexStorage3DMultisampleOESContextANGLE
+    glTexStorageMem2DEXTContextANGLE
+    glTexStorageMem2DMultisampleEXTContextANGLE
+    glTexStorageMem3DEXTContextANGLE
+    glTexStorageMem3DMultisampleEXTContextANGLE
+    glTexSubImage2DContextANGLE
+    glTexSubImage2DRobustANGLEContextANGLE
+    glTexSubImage3DContextANGLE
+    glTexSubImage3DOESContextANGLE
+    glTexSubImage3DRobustANGLEContextANGLE
+    glTransformFeedbackVaryingsContextANGLE
+    glTranslatefContextANGLE
+    glTranslatexContextANGLE
+    glUniform1fContextANGLE
+    glUniform1fvContextANGLE
+    glUniform1iContextANGLE
+    glUniform1ivContextANGLE
+    glUniform1uiContextANGLE
+    glUniform1uivContextANGLE
+    glUniform2fContextANGLE
+    glUniform2fvContextANGLE
+    glUniform2iContextANGLE
+    glUniform2ivContextANGLE
+    glUniform2uiContextANGLE
+    glUniform2uivContextANGLE
+    glUniform3fContextANGLE
+    glUniform3fvContextANGLE
+    glUniform3iContextANGLE
+    glUniform3ivContextANGLE
+    glUniform3uiContextANGLE
+    glUniform3uivContextANGLE
+    glUniform4fContextANGLE
+    glUniform4fvContextANGLE
+    glUniform4iContextANGLE
+    glUniform4ivContextANGLE
+    glUniform4uiContextANGLE
+    glUniform4uivContextANGLE
+    glUniformBlockBindingContextANGLE
+    glUniformMatrix2fvContextANGLE
+    glUniformMatrix2x3fvContextANGLE
+    glUniformMatrix2x4fvContextANGLE
+    glUniformMatrix3fvContextANGLE
+    glUniformMatrix3x2fvContextANGLE
+    glUniformMatrix3x4fvContextANGLE
+    glUniformMatrix4fvContextANGLE
+    glUniformMatrix4x2fvContextANGLE
+    glUniformMatrix4x3fvContextANGLE
+    glUnmapBufferContextANGLE
+    glUnmapBufferOESContextANGLE
+    glUseProgramContextANGLE
+    glUseProgramStagesContextANGLE
+    glValidateProgramContextANGLE
+    glValidateProgramPipelineContextANGLE
+    glVertexAttrib1fContextANGLE
+    glVertexAttrib1fvContextANGLE
+    glVertexAttrib2fContextANGLE
+    glVertexAttrib2fvContextANGLE
+    glVertexAttrib3fContextANGLE
+    glVertexAttrib3fvContextANGLE
+    glVertexAttrib4fContextANGLE
+    glVertexAttrib4fvContextANGLE
+    glVertexAttribBindingContextANGLE
+    glVertexAttribDivisorContextANGLE
+    glVertexAttribDivisorANGLEContextANGLE
+    glVertexAttribDivisorEXTContextANGLE
+    glVertexAttribFormatContextANGLE
+    glVertexAttribI4iContextANGLE
+    glVertexAttribI4ivContextANGLE
+    glVertexAttribI4uiContextANGLE
+    glVertexAttribI4uivContextANGLE
+    glVertexAttribIFormatContextANGLE
+    glVertexAttribIPointerContextANGLE
+    glVertexAttribPointerContextANGLE
+    glVertexBindingDivisorContextANGLE
+    glVertexPointerContextANGLE
+    glViewportContextANGLE
+    glWaitSemaphoreEXTContextANGLE
+    glWaitSyncContextANGLE
+    glWeightPointerOESContextANGLE
+
+    ; EGL 1.0
+    EGL_ChooseConfig
+    EGL_CopyBuffers
+    EGL_CreateContext
+    EGL_CreatePbufferSurface
+    EGL_CreatePixmapSurface
+    EGL_CreateWindowSurface
+    EGL_DestroyContext
+    EGL_DestroySurface
+    EGL_GetConfigAttrib
+    EGL_GetConfigs
+    EGL_GetCurrentDisplay
+    EGL_GetCurrentSurface
+    EGL_GetDisplay
+    EGL_GetError
+    EGL_GetProcAddress
+    EGL_Initialize
+    EGL_MakeCurrent
+    EGL_QueryContext
+    EGL_QueryString
+    EGL_QuerySurface
+    EGL_SwapBuffers
+    EGL_Terminate
+    EGL_WaitGL
+    EGL_WaitNative
+
+    ; EGL 1.1
+    EGL_BindTexImage
+    EGL_ReleaseTexImage
+    EGL_SurfaceAttrib
+    EGL_SwapInterval
+
+    ; EGL 1.2
+    EGL_BindAPI
+    EGL_CreatePbufferFromClientBuffer
+    EGL_QueryAPI
+    EGL_ReleaseThread
+    EGL_WaitClient
+
+    ; EGL 1.4
+    EGL_GetCurrentContext
+
+    ; EGL 1.5
+    EGL_ClientWaitSync
+    EGL_CreateImage
+    EGL_CreatePlatformPixmapSurface
+    EGL_CreatePlatformWindowSurface
+    EGL_CreateSync
+    EGL_DestroyImage
+    EGL_DestroySync
+    EGL_GetPlatformDisplay
+    EGL_GetSyncAttrib
+    EGL_WaitSync
+
+    ; EGL_ANDROID_blob_cache
+    EGL_SetBlobCacheFuncsANDROID
+
+    ; EGL_ANDROID_get_frame_timestamps
+    EGL_GetCompositorTimingANDROID
+    EGL_GetCompositorTimingSupportedANDROID
+    EGL_GetFrameTimestampSupportedANDROID
+    EGL_GetFrameTimestampsANDROID
+    EGL_GetNextFrameIdANDROID
+
+    ; EGL_ANDROID_get_native_client_buffer
+    EGL_GetNativeClientBufferANDROID
+
+    ; EGL_ANDROID_native_fence_sync
+    EGL_DupNativeFenceFDANDROID
+
+    ; EGL_ANDROID_presentation_time
+    EGL_PresentationTimeANDROID
+
+    ; EGL_ANGLE_device_creation
+    EGL_CreateDeviceANGLE
+    EGL_ReleaseDeviceANGLE
+
+    ; EGL_ANGLE_feature_control
+    EGL_QueryDisplayAttribANGLE
+    EGL_QueryStringiANGLE
+
+    ; EGL_ANGLE_program_cache_control
+    EGL_ProgramCacheGetAttribANGLE
+    EGL_ProgramCachePopulateANGLE
+    EGL_ProgramCacheQueryANGLE
+    EGL_ProgramCacheResizeANGLE
+
+    ; EGL_ANGLE_query_surface_pointer
+    EGL_QuerySurfacePointerANGLE
+
+    ; EGL_ANGLE_stream_producer_d3d_texture
+    EGL_CreateStreamProducerD3DTextureANGLE
+    EGL_StreamPostD3DTextureANGLE
+
+    ; EGL_CHROMIUM_get_sync_values
+    EGL_GetSyncValuesCHROMIUM
+
+    ; EGL_EXT_device_query
+    EGL_QueryDeviceAttribEXT
+    EGL_QueryDeviceStringEXT
+    EGL_QueryDisplayAttribEXT
+
+    ; EGL_EXT_platform_base
+    EGL_CreatePlatformPixmapSurfaceEXT
+    EGL_CreatePlatformWindowSurfaceEXT
+    EGL_GetPlatformDisplayEXT
+
+    ; EGL_KHR_debug
+    EGL_DebugMessageControlKHR
+    EGL_LabelObjectKHR
+    EGL_QueryDebugKHR
+
+    ; EGL_KHR_fence_sync
+    EGL_ClientWaitSyncKHR
+    EGL_CreateSyncKHR
+    EGL_DestroySyncKHR
+    EGL_GetSyncAttribKHR
+
+    ; EGL_KHR_image
+    EGL_CreateImageKHR
+    EGL_DestroyImageKHR
+
+    ; EGL_KHR_stream
+    EGL_CreateStreamKHR
+    EGL_DestroyStreamKHR
+    EGL_QueryStreamKHR
+    EGL_QueryStreamu64KHR
+    EGL_StreamAttribKHR
+
+    ; EGL_KHR_stream_consumer_gltexture
+    EGL_StreamConsumerAcquireKHR
+    EGL_StreamConsumerGLTextureExternalKHR
+    EGL_StreamConsumerReleaseKHR
+
+    ; EGL_KHR_swap_buffers_with_damage
+    EGL_SwapBuffersWithDamageKHR
+
+    ; EGL_KHR_wait_sync
+    EGL_WaitSyncKHR
+
+    ; EGL_NV_post_sub_buffer
+    EGL_PostSubBufferNV
+
+    ; EGL_NV_stream_consumer_gltexture_yuv
+    EGL_StreamConsumerGLTextureExternalAttribsNV
diff --git a/gfx/angle/checkout/src/libGLESv2/proc_table_egl.h b/gfx/angle/checkout/src/libGLESv2/proc_table_egl.h
new file mode 100644
index 0000000000..38506e7c4c
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/proc_table_egl.h
@@ -0,0 +1,25 @@
+//
+// Copyright 2017 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// getProcAddress loader table:
+//   Mapping from a string entry point name to function address.
+//
+
+#ifndef LIBGLESV2_PROC_TABLE_H_
+#define LIBGLESV2_PROC_TABLE_H_
+
+#include <EGL/egl.h>
+#include <stddef.h>
+#include <utility>
+
+namespace egl
+{
+using ProcEntry = std::pair<const char *, __eglMustCastToProperFunctionPointerType>;
+
+extern ProcEntry g_procTable[];
+extern size_t g_numProcs;
+}  // namespace egl
+
+#endif  // LIBGLESV2_PROC_TABLE_H_
diff --git a/gfx/angle/checkout/src/libGLESv2/proc_table_egl_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/proc_table_egl_autogen.cpp
new file mode 100644
index 0000000000..3fc0850de4
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/proc_table_egl_autogen.cpp
@@ -0,0 +1,1495 @@
+// GENERATED FILE - DO NOT EDIT.
+// Generated by gen_proc_table.py using data from gl.xml, gl_angle_ext.xml, egl.xml,
+// egl_angle_ext.xml.
+//
+// Copyright 2019 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// getProcAddress loader table:
+//   Mapping from a string entry point name to function address.
+//
+
+#include "libGLESv2/proc_table_egl.h"
+
+#include "libGLESv2/entry_points_egl.h"
+#include "libGLESv2/entry_points_egl_ext.h"
+#include "libGLESv2/entry_points_gles_1_0_autogen.h"
+#include "libGLESv2/entry_points_gles_2_0_autogen.h"
+#include "libGLESv2/entry_points_gles_3_0_autogen.h"
+#include "libGLESv2/entry_points_gles_3_1_autogen.h"
+#include "libGLESv2/entry_points_gles_ext_autogen.h"
+#include "platform/Platform.h"
+
+#define P(FUNC) reinterpret_cast<__eglMustCastToProperFunctionPointerType>(FUNC)
+
+namespace egl
+{
+ProcEntry g_procTable[] = {
+    {"ANGLEGetDisplayPlatform", P(ANGLEGetDisplayPlatform)},
+    {"ANGLEResetDisplayPlatform", P(ANGLEResetDisplayPlatform)},
+    {"eglBindAPI", P(EGL_BindAPI)},
+    {"eglBindTexImage", P(EGL_BindTexImage)},
+    {"eglChooseConfig", P(EGL_ChooseConfig)},
+    {"eglClientWaitSync", P(EGL_ClientWaitSync)},
+    {"eglClientWaitSyncKHR", P(EGL_ClientWaitSyncKHR)},
+    {"eglCopyBuffers", P(EGL_CopyBuffers)},
+    {"eglCreateContext", P(EGL_CreateContext)},
+    {"eglCreateDeviceANGLE", P(EGL_CreateDeviceANGLE)},
+    {"eglCreateImage", P(EGL_CreateImage)},
+    {"eglCreateImageKHR", P(EGL_CreateImageKHR)},
+    {"eglCreatePbufferFromClientBuffer", P(EGL_CreatePbufferFromClientBuffer)},
+    {"eglCreatePbufferSurface", P(EGL_CreatePbufferSurface)},
+    {"eglCreatePixmapSurface", P(EGL_CreatePixmapSurface)},
+    {"eglCreatePlatformPixmapSurface", P(EGL_CreatePlatformPixmapSurface)},
+    {"eglCreatePlatformPixmapSurfaceEXT", P(EGL_CreatePlatformPixmapSurfaceEXT)},
+    {"eglCreatePlatformWindowSurface", P(EGL_CreatePlatformWindowSurface)},
+    {"eglCreatePlatformWindowSurfaceEXT", P(EGL_CreatePlatformWindowSurfaceEXT)},
+    {"eglCreateStreamKHR", P(EGL_CreateStreamKHR)},
+    {"eglCreateStreamProducerD3DTextureANGLE", P(EGL_CreateStreamProducerD3DTextureANGLE)},
+    {"eglCreateSync", P(EGL_CreateSync)},
+    {"eglCreateSyncKHR", P(EGL_CreateSyncKHR)},
+    {"eglCreateWindowSurface", P(EGL_CreateWindowSurface)},
+    {"eglDebugMessageControlKHR", P(EGL_DebugMessageControlKHR)},
+    {"eglDestroyContext", P(EGL_DestroyContext)},
+    {"eglDestroyImage", P(EGL_DestroyImage)},
+    {"eglDestroyImageKHR", P(EGL_DestroyImageKHR)},
+    {"eglDestroyStreamKHR", P(EGL_DestroyStreamKHR)},
+    {"eglDestroySurface", P(EGL_DestroySurface)},
+    {"eglDestroySync", P(EGL_DestroySync)},
+    {"eglDestroySyncKHR", P(EGL_DestroySyncKHR)},
+    {"eglDupNativeFenceFDANDROID", P(EGL_DupNativeFenceFDANDROID)},
+    {"eglGetCompositorTimingANDROID", P(EGL_GetCompositorTimingANDROID)},
+    {"eglGetCompositorTimingSupportedANDROID", P(EGL_GetCompositorTimingSupportedANDROID)},
+    {"eglGetConfigAttrib", P(EGL_GetConfigAttrib)},
+    {"eglGetConfigs", P(EGL_GetConfigs)},
+    {"eglGetCurrentContext", P(EGL_GetCurrentContext)},
+    {"eglGetCurrentDisplay", P(EGL_GetCurrentDisplay)},
+    {"eglGetCurrentSurface", P(EGL_GetCurrentSurface)},
+    {"eglGetDisplay", P(EGL_GetDisplay)},
+    {"eglGetError", P(EGL_GetError)},
+    {"eglGetFrameTimestampSupportedANDROID", P(EGL_GetFrameTimestampSupportedANDROID)},
+    {"eglGetFrameTimestampsANDROID", P(EGL_GetFrameTimestampsANDROID)},
+    {"eglGetNativeClientBufferANDROID", P(EGL_GetNativeClientBufferANDROID)},
+    {"eglGetNextFrameIdANDROID", P(EGL_GetNextFrameIdANDROID)},
+    {"eglGetPlatformDisplay", P(EGL_GetPlatformDisplay)},
+    {"eglGetPlatformDisplayEXT", P(EGL_GetPlatformDisplayEXT)},
+    {"eglGetProcAddress", P(EGL_GetProcAddress)},
+    {"eglGetSyncAttrib", P(EGL_GetSyncAttrib)},
+    {"eglGetSyncAttribKHR", P(EGL_GetSyncAttribKHR)},
+    {"eglGetSyncValuesCHROMIUM", P(EGL_GetSyncValuesCHROMIUM)},
+    {"eglInitialize", P(EGL_Initialize)},
+    {"eglLabelObjectKHR", P(EGL_LabelObjectKHR)},
+    {"eglMakeCurrent", P(EGL_MakeCurrent)},
+    {"eglPostSubBufferNV", P(EGL_PostSubBufferNV)},
+    {"eglPresentationTimeANDROID", P(EGL_PresentationTimeANDROID)},
+    {"eglProgramCacheGetAttribANGLE", P(EGL_ProgramCacheGetAttribANGLE)},
+    {"eglProgramCachePopulateANGLE", P(EGL_ProgramCachePopulateANGLE)},
+    {"eglProgramCacheQueryANGLE", P(EGL_ProgramCacheQueryANGLE)},
+    {"eglProgramCacheResizeANGLE", P(EGL_ProgramCacheResizeANGLE)},
+    {"eglQueryAPI", P(EGL_QueryAPI)},
+    {"eglQueryContext", P(EGL_QueryContext)},
+    {"eglQueryDebugKHR", P(EGL_QueryDebugKHR)},
+    {"eglQueryDeviceAttribEXT", P(EGL_QueryDeviceAttribEXT)},
+    {"eglQueryDeviceStringEXT", P(EGL_QueryDeviceStringEXT)},
+    {"eglQueryDisplayAttribANGLE", P(EGL_QueryDisplayAttribANGLE)},
+    {"eglQueryDisplayAttribEXT", P(EGL_QueryDisplayAttribEXT)},
+    {"eglQueryStreamKHR", P(EGL_QueryStreamKHR)},
+    {"eglQueryStreamu64KHR", P(EGL_QueryStreamu64KHR)},
+    {"eglQueryString", P(EGL_QueryString)},
+    {"eglQueryStringiANGLE", P(EGL_QueryStringiANGLE)},
+    {"eglQuerySurface", P(EGL_QuerySurface)},
+    {"eglQuerySurfacePointerANGLE", P(EGL_QuerySurfacePointerANGLE)},
+    {"eglReleaseDeviceANGLE", P(EGL_ReleaseDeviceANGLE)},
+    {"eglReleaseTexImage", P(EGL_ReleaseTexImage)},
+    {"eglReleaseThread", P(EGL_ReleaseThread)},
+    {"eglSetBlobCacheFuncsANDROID", P(EGL_SetBlobCacheFuncsANDROID)},
+    {"eglStreamAttribKHR", P(EGL_StreamAttribKHR)},
+    {"eglStreamConsumerAcquireKHR", P(EGL_StreamConsumerAcquireKHR)},
+    {"eglStreamConsumerGLTextureExternalAttribsNV",
+     P(EGL_StreamConsumerGLTextureExternalAttribsNV)},
+    {"eglStreamConsumerGLTextureExternalKHR", P(EGL_StreamConsumerGLTextureExternalKHR)},
+    {"eglStreamConsumerReleaseKHR", P(EGL_StreamConsumerReleaseKHR)},
+    {"eglStreamPostD3DTextureANGLE", P(EGL_StreamPostD3DTextureANGLE)},
+    {"eglSurfaceAttrib", P(EGL_SurfaceAttrib)},
+    {"eglSwapBuffers", P(EGL_SwapBuffers)},
+    {"eglSwapBuffersWithDamageKHR", P(EGL_SwapBuffersWithDamageKHR)},
+    {"eglSwapInterval", P(EGL_SwapInterval)},
+    {"eglTerminate", P(EGL_Terminate)},
+    {"eglWaitClient", P(EGL_WaitClient)},
+    {"eglWaitGL", P(EGL_WaitGL)},
+    {"eglWaitNative", P(EGL_WaitNative)},
+    {"eglWaitSync", P(EGL_WaitSync)},
+    {"eglWaitSyncKHR", P(EGL_WaitSyncKHR)},
+    {"glActiveShaderProgram", P(gl::ActiveShaderProgram)},
+    {"glActiveShaderProgramContextANGLE", P(gl::ActiveShaderProgramContextANGLE)},
+    {"glActiveTexture", P(gl::ActiveTexture)},
+    {"glActiveTextureContextANGLE", P(gl::ActiveTextureContextANGLE)},
+    {"glAlphaFunc", P(gl::AlphaFunc)},
+    {"glAlphaFuncContextANGLE", P(gl::AlphaFuncContextANGLE)},
+    {"glAlphaFuncx", P(gl::AlphaFuncx)},
+    {"glAlphaFuncxContextANGLE", P(gl::AlphaFuncxContextANGLE)},
+    {"glAttachShader", P(gl::AttachShader)},
+    {"glAttachShaderContextANGLE", P(gl::AttachShaderContextANGLE)},
+    {"glBeginQuery", P(gl::BeginQuery)},
+    {"glBeginQueryContextANGLE", P(gl::BeginQueryContextANGLE)},
+    {"glBeginQueryEXT", P(gl::BeginQueryEXT)},
+    {"glBeginQueryEXTContextANGLE", P(gl::BeginQueryEXTContextANGLE)},
+    {"glBeginTransformFeedback", P(gl::BeginTransformFeedback)},
+    {"glBeginTransformFeedbackContextANGLE", P(gl::BeginTransformFeedbackContextANGLE)},
+    {"glBindAttribLocation", P(gl::BindAttribLocation)},
+    {"glBindAttribLocationContextANGLE", P(gl::BindAttribLocationContextANGLE)},
+    {"glBindBuffer", P(gl::BindBuffer)},
+    {"glBindBufferBase", P(gl::BindBufferBase)},
+    {"glBindBufferBaseContextANGLE", P(gl::BindBufferBaseContextANGLE)},
+    {"glBindBufferContextANGLE", P(gl::BindBufferContextANGLE)},
+    {"glBindBufferRange", P(gl::BindBufferRange)},
+    {"glBindBufferRangeContextANGLE", P(gl::BindBufferRangeContextANGLE)},
+    {"glBindFragDataLocationEXT", P(gl::BindFragDataLocationEXT)},
+    {"glBindFragDataLocationEXTContextANGLE", P(gl::BindFragDataLocationEXTContextANGLE)},
+    {"glBindFragDataLocationIndexedEXT", P(gl::BindFragDataLocationIndexedEXT)},
+    {"glBindFragDataLocationIndexedEXTContextANGLE",
+     P(gl::BindFragDataLocationIndexedEXTContextANGLE)},
+    {"glBindFragmentInputLocationCHROMIUM", P(gl::BindFragmentInputLocationCHROMIUM)},
+    {"glBindFragmentInputLocationCHROMIUMContextANGLE",
+     P(gl::BindFragmentInputLocationCHROMIUMContextANGLE)},
+    {"glBindFramebuffer", P(gl::BindFramebuffer)},
+    {"glBindFramebufferContextANGLE", P(gl::BindFramebufferContextANGLE)},
+    {"glBindFramebufferOES", P(gl::BindFramebufferOES)},
+    {"glBindFramebufferOESContextANGLE", P(gl::BindFramebufferOESContextANGLE)},
+    {"glBindImageTexture", P(gl::BindImageTexture)},
+    {"glBindImageTextureContextANGLE", P(gl::BindImageTextureContextANGLE)},
+    {"glBindProgramPipeline", P(gl::BindProgramPipeline)},
+    {"glBindProgramPipelineContextANGLE", P(gl::BindProgramPipelineContextANGLE)},
+    {"glBindRenderbuffer", P(gl::BindRenderbuffer)},
+    {"glBindRenderbufferContextANGLE", P(gl::BindRenderbufferContextANGLE)},
+    {"glBindRenderbufferOES", P(gl::BindRenderbufferOES)},
+    {"glBindRenderbufferOESContextANGLE", P(gl::BindRenderbufferOESContextANGLE)},
+    {"glBindSampler", P(gl::BindSampler)},
+    {"glBindSamplerContextANGLE", P(gl::BindSamplerContextANGLE)},
+    {"glBindTexture", P(gl::BindTexture)},
+    {"glBindTextureContextANGLE", P(gl::BindTextureContextANGLE)},
+    {"glBindTransformFeedback", P(gl::BindTransformFeedback)},
+    {"glBindTransformFeedbackContextANGLE", P(gl::BindTransformFeedbackContextANGLE)},
+    {"glBindUniformLocationCHROMIUM", P(gl::BindUniformLocationCHROMIUM)},
+    {"glBindUniformLocationCHROMIUMContextANGLE", P(gl::BindUniformLocationCHROMIUMContextANGLE)},
+    {"glBindVertexArray", P(gl::BindVertexArray)},
+    {"glBindVertexArrayContextANGLE", P(gl::BindVertexArrayContextANGLE)},
+    {"glBindVertexArrayOES", P(gl::BindVertexArrayOES)},
+    {"glBindVertexArrayOESContextANGLE", P(gl::BindVertexArrayOESContextANGLE)},
+    {"glBindVertexBuffer", P(gl::BindVertexBuffer)},
+    {"glBindVertexBufferContextANGLE", P(gl::BindVertexBufferContextANGLE)},
+    {"glBlendColor", P(gl::BlendColor)},
+    {"glBlendColorContextANGLE", P(gl::BlendColorContextANGLE)},
+    {"glBlendEquation", P(gl::BlendEquation)},
+    {"glBlendEquationContextANGLE", P(gl::BlendEquationContextANGLE)},
+    {"glBlendEquationSeparate", P(gl::BlendEquationSeparate)},
+    {"glBlendEquationSeparateContextANGLE", P(gl::BlendEquationSeparateContextANGLE)},
+    {"glBlendFunc", P(gl::BlendFunc)},
+    {"glBlendFuncContextANGLE", P(gl::BlendFuncContextANGLE)},
+    {"glBlendFuncSeparate", P(gl::BlendFuncSeparate)},
+    {"glBlendFuncSeparateContextANGLE", P(gl::BlendFuncSeparateContextANGLE)},
+    {"glBlitFramebuffer", P(gl::BlitFramebuffer)},
+    {"glBlitFramebufferANGLE", P(gl::BlitFramebufferANGLE)},
+    {"glBlitFramebufferANGLEContextANGLE", P(gl::BlitFramebufferANGLEContextANGLE)},
+    {"glBlitFramebufferContextANGLE", P(gl::BlitFramebufferContextANGLE)},
+    {"glBufferData", P(gl::BufferData)},
+    {"glBufferDataContextANGLE", P(gl::BufferDataContextANGLE)},
+    {"glBufferStorageMemEXT", P(gl::BufferStorageMemEXT)},
+    {"glBufferStorageMemEXTContextANGLE", P(gl::BufferStorageMemEXTContextANGLE)},
+    {"glBufferSubData", P(gl::BufferSubData)},
+    {"glBufferSubDataContextANGLE", P(gl::BufferSubDataContextANGLE)},
+    {"glCheckFramebufferStatus", P(gl::CheckFramebufferStatus)},
+    {"glCheckFramebufferStatusContextANGLE", P(gl::CheckFramebufferStatusContextANGLE)},
+    {"glCheckFramebufferStatusOES", P(gl::CheckFramebufferStatusOES)},
+    {"glCheckFramebufferStatusOESContextANGLE", P(gl::CheckFramebufferStatusOESContextANGLE)},
+    {"glClear", P(gl::Clear)},
+    {"glClearBufferfi", P(gl::ClearBufferfi)},
+    {"glClearBufferfiContextANGLE", P(gl::ClearBufferfiContextANGLE)},
+    {"glClearBufferfv", P(gl::ClearBufferfv)},
+    {"glClearBufferfvContextANGLE", P(gl::ClearBufferfvContextANGLE)},
+    {"glClearBufferiv", P(gl::ClearBufferiv)},
+    {"glClearBufferivContextANGLE", P(gl::ClearBufferivContextANGLE)},
+    {"glClearBufferuiv", P(gl::ClearBufferuiv)},
+    {"glClearBufferuivContextANGLE", P(gl::ClearBufferuivContextANGLE)},
+    {"glClearColor", P(gl::ClearColor)},
+    {"glClearColorContextANGLE", P(gl::ClearColorContextANGLE)},
+    {"glClearColorx", P(gl::ClearColorx)},
+    {"glClearColorxContextANGLE", P(gl::ClearColorxContextANGLE)},
+    {"glClearContextANGLE", P(gl::ClearContextANGLE)},
+    {"glClearDepthf", P(gl::ClearDepthf)},
+    {"glClearDepthfContextANGLE", P(gl::ClearDepthfContextANGLE)},
+    {"glClearDepthx", P(gl::ClearDepthx)},
+    {"glClearDepthxContextANGLE", P(gl::ClearDepthxContextANGLE)},
+    {"glClearStencil", P(gl::ClearStencil)},
+    {"glClearStencilContextANGLE", P(gl::ClearStencilContextANGLE)},
+    {"glClientActiveTexture", P(gl::ClientActiveTexture)},
+    {"glClientActiveTextureContextANGLE", P(gl::ClientActiveTextureContextANGLE)},
+    {"glClientWaitSync", P(gl::ClientWaitSync)},
+    {"glClientWaitSyncContextANGLE", P(gl::ClientWaitSyncContextANGLE)},
+    {"glClipPlanef", P(gl::ClipPlanef)},
+    {"glClipPlanefContextANGLE", P(gl::ClipPlanefContextANGLE)},
+    {"glClipPlanex", P(gl::ClipPlanex)},
+    {"glClipPlanexContextANGLE", P(gl::ClipPlanexContextANGLE)},
+    {"glColor4f", P(gl::Color4f)},
+    {"glColor4fContextANGLE", P(gl::Color4fContextANGLE)},
+    {"glColor4ub", P(gl::Color4ub)},
+    {"glColor4ubContextANGLE", P(gl::Color4ubContextANGLE)},
+    {"glColor4x", P(gl::Color4x)},
+    {"glColor4xContextANGLE", P(gl::Color4xContextANGLE)},
+    {"glColorMask", P(gl::ColorMask)},
+    {"glColorMaskContextANGLE", P(gl::ColorMaskContextANGLE)},
+    {"glColorPointer", P(gl::ColorPointer)},
+    {"glColorPointerContextANGLE", P(gl::ColorPointerContextANGLE)},
+    {"glCompileShader", P(gl::CompileShader)},
+    {"glCompileShaderContextANGLE", P(gl::CompileShaderContextANGLE)},
+    {"glCompressedCopyTextureCHROMIUM", P(gl::CompressedCopyTextureCHROMIUM)},
+    {"glCompressedCopyTextureCHROMIUMContextANGLE",
+     P(gl::CompressedCopyTextureCHROMIUMContextANGLE)},
+    {"glCompressedTexImage2D", P(gl::CompressedTexImage2D)},
+    {"glCompressedTexImage2DContextANGLE", P(gl::CompressedTexImage2DContextANGLE)},
+    {"glCompressedTexImage2DRobustANGLE", P(gl::CompressedTexImage2DRobustANGLE)},
+    {"glCompressedTexImage2DRobustANGLEContextANGLE",
+     P(gl::CompressedTexImage2DRobustANGLEContextANGLE)},
+    {"glCompressedTexImage3D", P(gl::CompressedTexImage3D)},
+    {"glCompressedTexImage3DContextANGLE", P(gl::CompressedTexImage3DContextANGLE)},
+    {"glCompressedTexImage3DOES", P(gl::CompressedTexImage3DOES)},
+    {"glCompressedTexImage3DOESContextANGLE", P(gl::CompressedTexImage3DOESContextANGLE)},
+    {"glCompressedTexImage3DRobustANGLE", P(gl::CompressedTexImage3DRobustANGLE)},
+    {"glCompressedTexImage3DRobustANGLEContextANGLE",
+     P(gl::CompressedTexImage3DRobustANGLEContextANGLE)},
+    {"glCompressedTexSubImage2D", P(gl::CompressedTexSubImage2D)},
+    {"glCompressedTexSubImage2DContextANGLE", P(gl::CompressedTexSubImage2DContextANGLE)},
+    {"glCompressedTexSubImage2DRobustANGLE", P(gl::CompressedTexSubImage2DRobustANGLE)},
+    {"glCompressedTexSubImage2DRobustANGLEContextANGLE",
+     P(gl::CompressedTexSubImage2DRobustANGLEContextANGLE)},
+    {"glCompressedTexSubImage3D", P(gl::CompressedTexSubImage3D)},
+    {"glCompressedTexSubImage3DContextANGLE", P(gl::CompressedTexSubImage3DContextANGLE)},
+    {"glCompressedTexSubImage3DOES", P(gl::CompressedTexSubImage3DOES)},
+    {"glCompressedTexSubImage3DOESContextANGLE", P(gl::CompressedTexSubImage3DOESContextANGLE)},
+    {"glCompressedTexSubImage3DRobustANGLE", P(gl::CompressedTexSubImage3DRobustANGLE)},
+    {"glCompressedTexSubImage3DRobustANGLEContextANGLE",
+     P(gl::CompressedTexSubImage3DRobustANGLEContextANGLE)},
+    {"glCopyBufferSubData", P(gl::CopyBufferSubData)},
+    {"glCopyBufferSubDataContextANGLE", P(gl::CopyBufferSubDataContextANGLE)},
+    {"glCopySubTexture3DANGLE", P(gl::CopySubTexture3DANGLE)},
+    {"glCopySubTexture3DANGLEContextANGLE", P(gl::CopySubTexture3DANGLEContextANGLE)},
+    {"glCopySubTextureCHROMIUM", P(gl::CopySubTextureCHROMIUM)},
+    {"glCopySubTextureCHROMIUMContextANGLE", P(gl::CopySubTextureCHROMIUMContextANGLE)},
+    {"glCopyTexImage2D", P(gl::CopyTexImage2D)},
+    {"glCopyTexImage2DContextANGLE", P(gl::CopyTexImage2DContextANGLE)},
+    {"glCopyTexSubImage2D", P(gl::CopyTexSubImage2D)},
+    {"glCopyTexSubImage2DContextANGLE", P(gl::CopyTexSubImage2DContextANGLE)},
+    {"glCopyTexSubImage3D", P(gl::CopyTexSubImage3D)},
+    {"glCopyTexSubImage3DContextANGLE", P(gl::CopyTexSubImage3DContextANGLE)},
+    {"glCopyTexSubImage3DOES", P(gl::CopyTexSubImage3DOES)},
+    {"glCopyTexSubImage3DOESContextANGLE", P(gl::CopyTexSubImage3DOESContextANGLE)},
+    {"glCopyTexture3DANGLE", P(gl::CopyTexture3DANGLE)},
+    {"glCopyTexture3DANGLEContextANGLE", P(gl::CopyTexture3DANGLEContextANGLE)},
+    {"glCopyTextureCHROMIUM", P(gl::CopyTextureCHROMIUM)},
+    {"glCopyTextureCHROMIUMContextANGLE", P(gl::CopyTextureCHROMIUMContextANGLE)},
+    {"glCoverFillPathCHROMIUM", P(gl::CoverFillPathCHROMIUM)},
+    {"glCoverFillPathCHROMIUMContextANGLE", P(gl::CoverFillPathCHROMIUMContextANGLE)},
+    {"glCoverFillPathInstancedCHROMIUM", P(gl::CoverFillPathInstancedCHROMIUM)},
+    {"glCoverFillPathInstancedCHROMIUMContextANGLE",
+     P(gl::CoverFillPathInstancedCHROMIUMContextANGLE)},
+    {"glCoverStrokePathCHROMIUM", P(gl::CoverStrokePathCHROMIUM)},
+    {"glCoverStrokePathCHROMIUMContextANGLE", P(gl::CoverStrokePathCHROMIUMContextANGLE)},
+    {"glCoverStrokePathInstancedCHROMIUM", P(gl::CoverStrokePathInstancedCHROMIUM)},
+    {"glCoverStrokePathInstancedCHROMIUMContextANGLE",
+     P(gl::CoverStrokePathInstancedCHROMIUMContextANGLE)},
+    {"glCoverageModulationCHROMIUM", P(gl::CoverageModulationCHROMIUM)},
+    {"glCoverageModulationCHROMIUMContextANGLE", P(gl::CoverageModulationCHROMIUMContextANGLE)},
+    {"glCreateMemoryObjectsEXT", P(gl::CreateMemoryObjectsEXT)},
+    {"glCreateMemoryObjectsEXTContextANGLE", P(gl::CreateMemoryObjectsEXTContextANGLE)},
+    {"glCreateProgram", P(gl::CreateProgram)},
+    {"glCreateProgramContextANGLE", P(gl::CreateProgramContextANGLE)},
+    {"glCreateShader", P(gl::CreateShader)},
+    {"glCreateShaderContextANGLE", P(gl::CreateShaderContextANGLE)},
+    {"glCreateShaderProgramv", P(gl::CreateShaderProgramv)},
+    {"glCreateShaderProgramvContextANGLE", P(gl::CreateShaderProgramvContextANGLE)},
+    {"glCullFace", P(gl::CullFace)},
+    {"glCullFaceContextANGLE", P(gl::CullFaceContextANGLE)},
+    {"glCurrentPaletteMatrixOES", P(gl::CurrentPaletteMatrixOES)},
+    {"glCurrentPaletteMatrixOESContextANGLE", P(gl::CurrentPaletteMatrixOESContextANGLE)},
+    {"glDebugMessageCallbackKHR", P(gl::DebugMessageCallbackKHR)},
+    {"glDebugMessageCallbackKHRContextANGLE", P(gl::DebugMessageCallbackKHRContextANGLE)},
+    {"glDebugMessageControlKHR", P(gl::DebugMessageControlKHR)},
+    {"glDebugMessageControlKHRContextANGLE", P(gl::DebugMessageControlKHRContextANGLE)},
+    {"glDebugMessageInsertKHR", P(gl::DebugMessageInsertKHR)},
+    {"glDebugMessageInsertKHRContextANGLE", P(gl::DebugMessageInsertKHRContextANGLE)},
+    {"glDeleteBuffers", P(gl::DeleteBuffers)},
+    {"glDeleteBuffersContextANGLE", P(gl::DeleteBuffersContextANGLE)},
+    {"glDeleteFencesNV", P(gl::DeleteFencesNV)},
+    {"glDeleteFencesNVContextANGLE", P(gl::DeleteFencesNVContextANGLE)},
+    {"glDeleteFramebuffers", P(gl::DeleteFramebuffers)},
+    {"glDeleteFramebuffersContextANGLE", P(gl::DeleteFramebuffersContextANGLE)},
+    {"glDeleteFramebuffersOES", P(gl::DeleteFramebuffersOES)},
+    {"glDeleteFramebuffersOESContextANGLE", P(gl::DeleteFramebuffersOESContextANGLE)},
+    {"glDeleteMemoryObjectsEXT", P(gl::DeleteMemoryObjectsEXT)},
+    {"glDeleteMemoryObjectsEXTContextANGLE", P(gl::DeleteMemoryObjectsEXTContextANGLE)},
+    {"glDeletePathsCHROMIUM", P(gl::DeletePathsCHROMIUM)},
+    {"glDeletePathsCHROMIUMContextANGLE", P(gl::DeletePathsCHROMIUMContextANGLE)},
+    {"glDeleteProgram", P(gl::DeleteProgram)},
+    {"glDeleteProgramContextANGLE", P(gl::DeleteProgramContextANGLE)},
+    {"glDeleteProgramPipelines", P(gl::DeleteProgramPipelines)},
+    {"glDeleteProgramPipelinesContextANGLE", P(gl::DeleteProgramPipelinesContextANGLE)},
+    {"glDeleteQueries", P(gl::DeleteQueries)},
+    {"glDeleteQueriesContextANGLE", P(gl::DeleteQueriesContextANGLE)},
+    {"glDeleteQueriesEXT", P(gl::DeleteQueriesEXT)},
+    {"glDeleteQueriesEXTContextANGLE", P(gl::DeleteQueriesEXTContextANGLE)},
+    {"glDeleteRenderbuffers", P(gl::DeleteRenderbuffers)},
+    {"glDeleteRenderbuffersContextANGLE", P(gl::DeleteRenderbuffersContextANGLE)},
+    {"glDeleteRenderbuffersOES", P(gl::DeleteRenderbuffersOES)},
+    {"glDeleteRenderbuffersOESContextANGLE", P(gl::DeleteRenderbuffersOESContextANGLE)},
+    {"glDeleteSamplers", P(gl::DeleteSamplers)},
+    {"glDeleteSamplersContextANGLE", P(gl::DeleteSamplersContextANGLE)},
+    {"glDeleteSemaphoresEXT", P(gl::DeleteSemaphoresEXT)},
+    {"glDeleteSemaphoresEXTContextANGLE", P(gl::DeleteSemaphoresEXTContextANGLE)},
+    {"glDeleteShader", P(gl::DeleteShader)},
+    {"glDeleteShaderContextANGLE", P(gl::DeleteShaderContextANGLE)},
+    {"glDeleteSync", P(gl::DeleteSync)},
+    {"glDeleteSyncContextANGLE", P(gl::DeleteSyncContextANGLE)},
+    {"glDeleteTextures", P(gl::DeleteTextures)},
+    {"glDeleteTexturesContextANGLE", P(gl::DeleteTexturesContextANGLE)},
+    {"glDeleteTransformFeedbacks", P(gl::DeleteTransformFeedbacks)},
+    {"glDeleteTransformFeedbacksContextANGLE", P(gl::DeleteTransformFeedbacksContextANGLE)},
+    {"glDeleteVertexArrays", P(gl::DeleteVertexArrays)},
+    {"glDeleteVertexArraysContextANGLE", P(gl::DeleteVertexArraysContextANGLE)},
+    {"glDeleteVertexArraysOES", P(gl::DeleteVertexArraysOES)},
+    {"glDeleteVertexArraysOESContextANGLE", P(gl::DeleteVertexArraysOESContextANGLE)},
+    {"glDepthFunc", P(gl::DepthFunc)},
+    {"glDepthFuncContextANGLE", P(gl::DepthFuncContextANGLE)},
+    {"glDepthMask", P(gl::DepthMask)},
+    {"glDepthMaskContextANGLE", P(gl::DepthMaskContextANGLE)},
+    {"glDepthRangef", P(gl::DepthRangef)},
+    {"glDepthRangefContextANGLE", P(gl::DepthRangefContextANGLE)},
+    {"glDepthRangex", P(gl::DepthRangex)},
+    {"glDepthRangexContextANGLE", P(gl::DepthRangexContextANGLE)},
+    {"glDetachShader", P(gl::DetachShader)},
+    {"glDetachShaderContextANGLE", P(gl::DetachShaderContextANGLE)},
+    {"glDisable", P(gl::Disable)},
+    {"glDisableClientState", P(gl::DisableClientState)},
+    {"glDisableClientStateContextANGLE", P(gl::DisableClientStateContextANGLE)},
+    {"glDisableContextANGLE", P(gl::DisableContextANGLE)},
+    {"glDisableVertexAttribArray", P(gl::DisableVertexAttribArray)},
+    {"glDisableVertexAttribArrayContextANGLE", P(gl::DisableVertexAttribArrayContextANGLE)},
+    {"glDiscardFramebufferEXT", P(gl::DiscardFramebufferEXT)},
+    {"glDiscardFramebufferEXTContextANGLE", P(gl::DiscardFramebufferEXTContextANGLE)},
+    {"glDispatchCompute", P(gl::DispatchCompute)},
+    {"glDispatchComputeContextANGLE", P(gl::DispatchComputeContextANGLE)},
+    {"glDispatchComputeIndirect", P(gl::DispatchComputeIndirect)},
+    {"glDispatchComputeIndirectContextANGLE", P(gl::DispatchComputeIndirectContextANGLE)},
+    {"glDrawArrays", P(gl::DrawArrays)},
+    {"glDrawArraysContextANGLE", P(gl::DrawArraysContextANGLE)},
+    {"glDrawArraysIndirect", P(gl::DrawArraysIndirect)},
+    {"glDrawArraysIndirectContextANGLE", P(gl::DrawArraysIndirectContextANGLE)},
+    {"glDrawArraysInstanced", P(gl::DrawArraysInstanced)},
+    {"glDrawArraysInstancedANGLE", P(gl::DrawArraysInstancedANGLE)},
+    {"glDrawArraysInstancedANGLEContextANGLE", P(gl::DrawArraysInstancedANGLEContextANGLE)},
+    {"glDrawArraysInstancedContextANGLE", P(gl::DrawArraysInstancedContextANGLE)},
+    {"glDrawArraysInstancedEXT", P(gl::DrawArraysInstancedEXT)},
+    {"glDrawArraysInstancedEXTContextANGLE", P(gl::DrawArraysInstancedEXTContextANGLE)},
+    {"glDrawBuffers", P(gl::DrawBuffers)},
+    {"glDrawBuffersContextANGLE", P(gl::DrawBuffersContextANGLE)},
+    {"glDrawBuffersEXT", P(gl::DrawBuffersEXT)},
+    {"glDrawBuffersEXTContextANGLE", P(gl::DrawBuffersEXTContextANGLE)},
+    {"glDrawElements", P(gl::DrawElements)},
+    {"glDrawElementsContextANGLE", P(gl::DrawElementsContextANGLE)},
+    {"glDrawElementsIndirect", P(gl::DrawElementsIndirect)},
+    {"glDrawElementsIndirectContextANGLE", P(gl::DrawElementsIndirectContextANGLE)},
+    {"glDrawElementsInstanced", P(gl::DrawElementsInstanced)},
+    {"glDrawElementsInstancedANGLE", P(gl::DrawElementsInstancedANGLE)},
+    {"glDrawElementsInstancedANGLEContextANGLE", P(gl::DrawElementsInstancedANGLEContextANGLE)},
+    {"glDrawElementsInstancedContextANGLE", P(gl::DrawElementsInstancedContextANGLE)},
+    {"glDrawElementsInstancedEXT", P(gl::DrawElementsInstancedEXT)},
+    {"glDrawElementsInstancedEXTContextANGLE", P(gl::DrawElementsInstancedEXTContextANGLE)},
+    {"glDrawRangeElements", P(gl::DrawRangeElements)},
+    {"glDrawRangeElementsContextANGLE", P(gl::DrawRangeElementsContextANGLE)},
+    {"glDrawTexfOES", P(gl::DrawTexfOES)},
+    {"glDrawTexfOESContextANGLE", P(gl::DrawTexfOESContextANGLE)},
+    {"glDrawTexfvOES", P(gl::DrawTexfvOES)},
+    {"glDrawTexfvOESContextANGLE", P(gl::DrawTexfvOESContextANGLE)},
+    {"glDrawTexiOES", P(gl::DrawTexiOES)},
+    {"glDrawTexiOESContextANGLE", P(gl::DrawTexiOESContextANGLE)},
+    {"glDrawTexivOES", P(gl::DrawTexivOES)},
+    {"glDrawTexivOESContextANGLE", P(gl::DrawTexivOESContextANGLE)},
+    {"glDrawTexsOES", P(gl::DrawTexsOES)},
+    {"glDrawTexsOESContextANGLE", P(gl::DrawTexsOESContextANGLE)},
+    {"glDrawTexsvOES", P(gl::DrawTexsvOES)},
+    {"glDrawTexsvOESContextANGLE", P(gl::DrawTexsvOESContextANGLE)},
+    {"glDrawTexxOES", P(gl::DrawTexxOES)},
+    {"glDrawTexxOESContextANGLE", P(gl::DrawTexxOESContextANGLE)},
+    {"glDrawTexxvOES", P(gl::DrawTexxvOES)},
+    {"glDrawTexxvOESContextANGLE", P(gl::DrawTexxvOESContextANGLE)},
+    {"glEGLImageTargetRenderbufferStorageOES", P(gl::EGLImageTargetRenderbufferStorageOES)},
+    {"glEGLImageTargetRenderbufferStorageOESContextANGLE",
+     P(gl::EGLImageTargetRenderbufferStorageOESContextANGLE)},
+    {"glEGLImageTargetTexture2DOES", P(gl::EGLImageTargetTexture2DOES)},
+    {"glEGLImageTargetTexture2DOESContextANGLE", P(gl::EGLImageTargetTexture2DOESContextANGLE)},
+    {"glEnable", P(gl::Enable)},
+    {"glEnableClientState", P(gl::EnableClientState)},
+    {"glEnableClientStateContextANGLE", P(gl::EnableClientStateContextANGLE)},
+    {"glEnableContextANGLE", P(gl::EnableContextANGLE)},
+    {"glEnableVertexAttribArray", P(gl::EnableVertexAttribArray)},
+    {"glEnableVertexAttribArrayContextANGLE", P(gl::EnableVertexAttribArrayContextANGLE)},
+    {"glEndQuery", P(gl::EndQuery)},
+    {"glEndQueryContextANGLE", P(gl::EndQueryContextANGLE)},
+    {"glEndQueryEXT", P(gl::EndQueryEXT)},
+    {"glEndQueryEXTContextANGLE", P(gl::EndQueryEXTContextANGLE)},
+    {"glEndTransformFeedback", P(gl::EndTransformFeedback)},
+    {"glEndTransformFeedbackContextANGLE", P(gl::EndTransformFeedbackContextANGLE)},
+    {"glFenceSync", P(gl::FenceSync)},
+    {"glFenceSyncContextANGLE", P(gl::FenceSyncContextANGLE)},
+    {"glFinish", P(gl::Finish)},
+    {"glFinishContextANGLE", P(gl::FinishContextANGLE)},
+    {"glFinishFenceNV", P(gl::FinishFenceNV)},
+    {"glFinishFenceNVContextANGLE", P(gl::FinishFenceNVContextANGLE)},
+    {"glFlush", P(gl::Flush)},
+    {"glFlushContextANGLE", P(gl::FlushContextANGLE)},
+    {"glFlushMappedBufferRange", P(gl::FlushMappedBufferRange)},
+    {"glFlushMappedBufferRangeContextANGLE", P(gl::FlushMappedBufferRangeContextANGLE)},
+    {"glFlushMappedBufferRangeEXT", P(gl::FlushMappedBufferRangeEXT)},
+    {"glFlushMappedBufferRangeEXTContextANGLE", P(gl::FlushMappedBufferRangeEXTContextANGLE)},
+    {"glFogf", P(gl::Fogf)},
+    {"glFogfContextANGLE", P(gl::FogfContextANGLE)},
+    {"glFogfv", P(gl::Fogfv)},
+    {"glFogfvContextANGLE", P(gl::FogfvContextANGLE)},
+    {"glFogx", P(gl::Fogx)},
+    {"glFogxContextANGLE", P(gl::FogxContextANGLE)},
+    {"glFogxv", P(gl::Fogxv)},
+    {"glFogxvContextANGLE", P(gl::FogxvContextANGLE)},
+    {"glFramebufferParameteri", P(gl::FramebufferParameteri)},
+    {"glFramebufferParameteriContextANGLE", P(gl::FramebufferParameteriContextANGLE)},
+    {"glFramebufferRenderbuffer", P(gl::FramebufferRenderbuffer)},
+    {"glFramebufferRenderbufferContextANGLE", P(gl::FramebufferRenderbufferContextANGLE)},
+    {"glFramebufferRenderbufferOES", P(gl::FramebufferRenderbufferOES)},
+    {"glFramebufferRenderbufferOESContextANGLE", P(gl::FramebufferRenderbufferOESContextANGLE)},
+    {"glFramebufferTexture2D", P(gl::FramebufferTexture2D)},
+    {"glFramebufferTexture2DContextANGLE", P(gl::FramebufferTexture2DContextANGLE)},
+    {"glFramebufferTexture2DOES", P(gl::FramebufferTexture2DOES)},
+    {"glFramebufferTexture2DOESContextANGLE", P(gl::FramebufferTexture2DOESContextANGLE)},
+    {"glFramebufferTexture3DOES", P(gl::FramebufferTexture3DOES)},
+    {"glFramebufferTexture3DOESContextANGLE", P(gl::FramebufferTexture3DOESContextANGLE)},
+    {"glFramebufferTextureEXT", P(gl::FramebufferTextureEXT)},
+    {"glFramebufferTextureEXTContextANGLE", P(gl::FramebufferTextureEXTContextANGLE)},
+    {"glFramebufferTextureLayer", P(gl::FramebufferTextureLayer)},
+    {"glFramebufferTextureLayerContextANGLE", P(gl::FramebufferTextureLayerContextANGLE)},
+    {"glFramebufferTextureMultiviewOVR", P(gl::FramebufferTextureMultiviewOVR)},
+    {"glFramebufferTextureMultiviewOVRContextANGLE",
+     P(gl::FramebufferTextureMultiviewOVRContextANGLE)},
+    {"glFrontFace", P(gl::FrontFace)},
+    {"glFrontFaceContextANGLE", P(gl::FrontFaceContextANGLE)},
+    {"glFrustumf", P(gl::Frustumf)},
+    {"glFrustumfContextANGLE", P(gl::FrustumfContextANGLE)},
+    {"glFrustumx", P(gl::Frustumx)},
+    {"glFrustumxContextANGLE", P(gl::FrustumxContextANGLE)},
+    {"glGenBuffers", P(gl::GenBuffers)},
+    {"glGenBuffersContextANGLE", P(gl::GenBuffersContextANGLE)},
+    {"glGenFencesNV", P(gl::GenFencesNV)},
+    {"glGenFencesNVContextANGLE", P(gl::GenFencesNVContextANGLE)},
+    {"glGenFramebuffers", P(gl::GenFramebuffers)},
+    {"glGenFramebuffersContextANGLE", P(gl::GenFramebuffersContextANGLE)},
+    {"glGenFramebuffersOES", P(gl::GenFramebuffersOES)},
+    {"glGenFramebuffersOESContextANGLE", P(gl::GenFramebuffersOESContextANGLE)},
+    {"glGenPathsCHROMIUM", P(gl::GenPathsCHROMIUM)},
+    {"glGenPathsCHROMIUMContextANGLE", P(gl::GenPathsCHROMIUMContextANGLE)},
+    {"glGenProgramPipelines", P(gl::GenProgramPipelines)},
+    {"glGenProgramPipelinesContextANGLE", P(gl::GenProgramPipelinesContextANGLE)},
+    {"glGenQueries", P(gl::GenQueries)},
+    {"glGenQueriesContextANGLE", P(gl::GenQueriesContextANGLE)},
+    {"glGenQueriesEXT", P(gl::GenQueriesEXT)},
+    {"glGenQueriesEXTContextANGLE", P(gl::GenQueriesEXTContextANGLE)},
+    {"glGenRenderbuffers", P(gl::GenRenderbuffers)},
+    {"glGenRenderbuffersContextANGLE", P(gl::GenRenderbuffersContextANGLE)},
+    {"glGenRenderbuffersOES", P(gl::GenRenderbuffersOES)},
+    {"glGenRenderbuffersOESContextANGLE", P(gl::GenRenderbuffersOESContextANGLE)},
+    {"glGenSamplers", P(gl::GenSamplers)},
+    {"glGenSamplersContextANGLE", P(gl::GenSamplersContextANGLE)},
+    {"glGenSemaphoresEXT", P(gl::GenSemaphoresEXT)},
+    {"glGenSemaphoresEXTContextANGLE", P(gl::GenSemaphoresEXTContextANGLE)},
+    {"glGenTextures", P(gl::GenTextures)},
+    {"glGenTexturesContextANGLE", P(gl::GenTexturesContextANGLE)},
+    {"glGenTransformFeedbacks", P(gl::GenTransformFeedbacks)},
+    {"glGenTransformFeedbacksContextANGLE", P(gl::GenTransformFeedbacksContextANGLE)},
+    {"glGenVertexArrays", P(gl::GenVertexArrays)},
+    {"glGenVertexArraysContextANGLE", P(gl::GenVertexArraysContextANGLE)},
+    {"glGenVertexArraysOES", P(gl::GenVertexArraysOES)},
+    {"glGenVertexArraysOESContextANGLE", P(gl::GenVertexArraysOESContextANGLE)},
+    {"glGenerateMipmap", P(gl::GenerateMipmap)},
+    {"glGenerateMipmapContextANGLE", P(gl::GenerateMipmapContextANGLE)},
+    {"glGenerateMipmapOES", P(gl::GenerateMipmapOES)},
+    {"glGenerateMipmapOESContextANGLE", P(gl::GenerateMipmapOESContextANGLE)},
+    {"glGetActiveAttrib", P(gl::GetActiveAttrib)},
+    {"glGetActiveAttribContextANGLE", P(gl::GetActiveAttribContextANGLE)},
+    {"glGetActiveUniform", P(gl::GetActiveUniform)},
+    {"glGetActiveUniformBlockName", P(gl::GetActiveUniformBlockName)},
+    {"glGetActiveUniformBlockNameContextANGLE", P(gl::GetActiveUniformBlockNameContextANGLE)},
+    {"glGetActiveUniformBlockiv", P(gl::GetActiveUniformBlockiv)},
+    {"glGetActiveUniformBlockivContextANGLE", P(gl::GetActiveUniformBlockivContextANGLE)},
+    {"glGetActiveUniformBlockivRobustANGLE", P(gl::GetActiveUniformBlockivRobustANGLE)},
+    {"glGetActiveUniformBlockivRobustANGLEContextANGLE",
+     P(gl::GetActiveUniformBlockivRobustANGLEContextANGLE)},
+    {"glGetActiveUniformContextANGLE", P(gl::GetActiveUniformContextANGLE)},
+    {"glGetActiveUniformsiv", P(gl::GetActiveUniformsiv)},
+    {"glGetActiveUniformsivContextANGLE", P(gl::GetActiveUniformsivContextANGLE)},
+    {"glGetAttachedShaders", P(gl::GetAttachedShaders)},
+    {"glGetAttachedShadersContextANGLE", P(gl::GetAttachedShadersContextANGLE)},
+    {"glGetAttribLocation", P(gl::GetAttribLocation)},
+    {"glGetAttribLocationContextANGLE", P(gl::GetAttribLocationContextANGLE)},
+    {"glGetBooleani_v", P(gl::GetBooleani_v)},
+    {"glGetBooleani_vContextANGLE", P(gl::GetBooleani_vContextANGLE)},
+    {"glGetBooleani_vRobustANGLE", P(gl::GetBooleani_vRobustANGLE)},
+    {"glGetBooleani_vRobustANGLEContextANGLE", P(gl::GetBooleani_vRobustANGLEContextANGLE)},
+    {"glGetBooleanv", P(gl::GetBooleanv)},
+    {"glGetBooleanvContextANGLE", P(gl::GetBooleanvContextANGLE)},
+    {"glGetBooleanvRobustANGLE", P(gl::GetBooleanvRobustANGLE)},
+    {"glGetBooleanvRobustANGLEContextANGLE", P(gl::GetBooleanvRobustANGLEContextANGLE)},
+    {"glGetBufferParameteri64v", P(gl::GetBufferParameteri64v)},
+    {"glGetBufferParameteri64vContextANGLE", P(gl::GetBufferParameteri64vContextANGLE)},
+    {"glGetBufferParameteri64vRobustANGLE", P(gl::GetBufferParameteri64vRobustANGLE)},
+    {"glGetBufferParameteri64vRobustANGLEContextANGLE",
+     P(gl::GetBufferParameteri64vRobustANGLEContextANGLE)},
+    {"glGetBufferParameteriv", P(gl::GetBufferParameteriv)},
+    {"glGetBufferParameterivContextANGLE", P(gl::GetBufferParameterivContextANGLE)},
+    {"glGetBufferParameterivRobustANGLE", P(gl::GetBufferParameterivRobustANGLE)},
+    {"glGetBufferParameterivRobustANGLEContextANGLE",
+     P(gl::GetBufferParameterivRobustANGLEContextANGLE)},
+    {"glGetBufferPointerv", P(gl::GetBufferPointerv)},
+    {"glGetBufferPointervContextANGLE", P(gl::GetBufferPointervContextANGLE)},
+    {"glGetBufferPointervOES", P(gl::GetBufferPointervOES)},
+    {"glGetBufferPointervOESContextANGLE", P(gl::GetBufferPointervOESContextANGLE)},
+    {"glGetBufferPointervRobustANGLE", P(gl::GetBufferPointervRobustANGLE)},
+    {"glGetBufferPointervRobustANGLEContextANGLE", P(gl::GetBufferPointervRobustANGLEContextANGLE)},
+    {"glGetClipPlanef", P(gl::GetClipPlanef)},
+    {"glGetClipPlanefContextANGLE", P(gl::GetClipPlanefContextANGLE)},
+    {"glGetClipPlanex", P(gl::GetClipPlanex)},
+    {"glGetClipPlanexContextANGLE", P(gl::GetClipPlanexContextANGLE)},
+    {"glGetDebugMessageLogKHR", P(gl::GetDebugMessageLogKHR)},
+    {"glGetDebugMessageLogKHRContextANGLE", P(gl::GetDebugMessageLogKHRContextANGLE)},
+    {"glGetError", P(gl::GetError)},
+    {"glGetErrorContextANGLE", P(gl::GetErrorContextANGLE)},
+    {"glGetFenceivNV", P(gl::GetFenceivNV)},
+    {"glGetFenceivNVContextANGLE", P(gl::GetFenceivNVContextANGLE)},
+    {"glGetFixedv", P(gl::GetFixedv)},
+    {"glGetFixedvContextANGLE", P(gl::GetFixedvContextANGLE)},
+    {"glGetFloatv", P(gl::GetFloatv)},
+    {"glGetFloatvContextANGLE", P(gl::GetFloatvContextANGLE)},
+    {"glGetFloatvRobustANGLE", P(gl::GetFloatvRobustANGLE)},
+    {"glGetFloatvRobustANGLEContextANGLE", P(gl::GetFloatvRobustANGLEContextANGLE)},
+    {"glGetFragDataIndexEXT", P(gl::GetFragDataIndexEXT)},
+    {"glGetFragDataIndexEXTContextANGLE", P(gl::GetFragDataIndexEXTContextANGLE)},
+    {"glGetFragDataLocation", P(gl::GetFragDataLocation)},
+    {"glGetFragDataLocationContextANGLE", P(gl::GetFragDataLocationContextANGLE)},
+    {"glGetFramebufferAttachmentParameteriv", P(gl::GetFramebufferAttachmentParameteriv)},
+    {"glGetFramebufferAttachmentParameterivContextANGLE",
+     P(gl::GetFramebufferAttachmentParameterivContextANGLE)},
+    {"glGetFramebufferAttachmentParameterivOES", P(gl::GetFramebufferAttachmentParameterivOES)},
+    {"glGetFramebufferAttachmentParameterivOESContextANGLE",
+     P(gl::GetFramebufferAttachmentParameterivOESContextANGLE)},
+    {"glGetFramebufferAttachmentParameterivRobustANGLE",
+     P(gl::GetFramebufferAttachmentParameterivRobustANGLE)},
+    {"glGetFramebufferAttachmentParameterivRobustANGLEContextANGLE",
+     P(gl::GetFramebufferAttachmentParameterivRobustANGLEContextANGLE)},
+    {"glGetFramebufferParameteriv", P(gl::GetFramebufferParameteriv)},
+    {"glGetFramebufferParameterivContextANGLE", P(gl::GetFramebufferParameterivContextANGLE)},
+    {"glGetFramebufferParameterivRobustANGLE", P(gl::GetFramebufferParameterivRobustANGLE)},
+    {"glGetFramebufferParameterivRobustANGLEContextANGLE",
+     P(gl::GetFramebufferParameterivRobustANGLEContextANGLE)},
+    {"glGetGraphicsResetStatusEXT", P(gl::GetGraphicsResetStatusEXT)},
+    {"glGetGraphicsResetStatusEXTContextANGLE", P(gl::GetGraphicsResetStatusEXTContextANGLE)},
+    {"glGetInteger64i_v", P(gl::GetInteger64i_v)},
+    {"glGetInteger64i_vContextANGLE", P(gl::GetInteger64i_vContextANGLE)},
+    {"glGetInteger64i_vRobustANGLE", P(gl::GetInteger64i_vRobustANGLE)},
+    {"glGetInteger64i_vRobustANGLEContextANGLE", P(gl::GetInteger64i_vRobustANGLEContextANGLE)},
+    {"glGetInteger64v", P(gl::GetInteger64v)},
+    {"glGetInteger64vContextANGLE", P(gl::GetInteger64vContextANGLE)},
+    {"glGetInteger64vRobustANGLE", P(gl::GetInteger64vRobustANGLE)},
+    {"glGetInteger64vRobustANGLEContextANGLE", P(gl::GetInteger64vRobustANGLEContextANGLE)},
+    {"glGetIntegeri_v", P(gl::GetIntegeri_v)},
+    {"glGetIntegeri_vContextANGLE", P(gl::GetIntegeri_vContextANGLE)},
+    {"glGetIntegeri_vRobustANGLE", P(gl::GetIntegeri_vRobustANGLE)},
+    {"glGetIntegeri_vRobustANGLEContextANGLE", P(gl::GetIntegeri_vRobustANGLEContextANGLE)},
+    {"glGetIntegerv", P(gl::GetIntegerv)},
+    {"glGetIntegervContextANGLE", P(gl::GetIntegervContextANGLE)},
+    {"glGetIntegervRobustANGLE", P(gl::GetIntegervRobustANGLE)},
+    {"glGetIntegervRobustANGLEContextANGLE", P(gl::GetIntegervRobustANGLEContextANGLE)},
+    {"glGetInternalformativ", P(gl::GetInternalformativ)},
+    {"glGetInternalformativContextANGLE", P(gl::GetInternalformativContextANGLE)},
+    {"glGetInternalformativRobustANGLE", P(gl::GetInternalformativRobustANGLE)},
+    {"glGetInternalformativRobustANGLEContextANGLE",
+     P(gl::GetInternalformativRobustANGLEContextANGLE)},
+    {"glGetLightfv", P(gl::GetLightfv)},
+    {"glGetLightfvContextANGLE", P(gl::GetLightfvContextANGLE)},
+    {"glGetLightxv", P(gl::GetLightxv)},
+    {"glGetLightxvContextANGLE", P(gl::GetLightxvContextANGLE)},
+    {"glGetMaterialfv", P(gl::GetMaterialfv)},
+    {"glGetMaterialfvContextANGLE", P(gl::GetMaterialfvContextANGLE)},
+    {"glGetMaterialxv", P(gl::GetMaterialxv)},
+    {"glGetMaterialxvContextANGLE", P(gl::GetMaterialxvContextANGLE)},
+    {"glGetMemoryObjectParameterivEXT", P(gl::GetMemoryObjectParameterivEXT)},
+    {"glGetMemoryObjectParameterivEXTContextANGLE",
+     P(gl::GetMemoryObjectParameterivEXTContextANGLE)},
+    {"glGetMultisamplefv", P(gl::GetMultisamplefv)},
+    {"glGetMultisamplefvANGLE", P(gl::GetMultisamplefvANGLE)},
+    {"glGetMultisamplefvANGLEContextANGLE", P(gl::GetMultisamplefvANGLEContextANGLE)},
+    {"glGetMultisamplefvContextANGLE", P(gl::GetMultisamplefvContextANGLE)},
+    {"glGetMultisamplefvRobustANGLE", P(gl::GetMultisamplefvRobustANGLE)},
+    {"glGetMultisamplefvRobustANGLEContextANGLE", P(gl::GetMultisamplefvRobustANGLEContextANGLE)},
+    {"glGetObjectLabelKHR", P(gl::GetObjectLabelKHR)},
+    {"glGetObjectLabelKHRContextANGLE", P(gl::GetObjectLabelKHRContextANGLE)},
+    {"glGetObjectPtrLabelKHR", P(gl::GetObjectPtrLabelKHR)},
+    {"glGetObjectPtrLabelKHRContextANGLE", P(gl::GetObjectPtrLabelKHRContextANGLE)},
+    {"glGetPathParameterfvCHROMIUM", P(gl::GetPathParameterfvCHROMIUM)},
+    {"glGetPathParameterfvCHROMIUMContextANGLE", P(gl::GetPathParameterfvCHROMIUMContextANGLE)},
+    {"glGetPathParameterivCHROMIUM", P(gl::GetPathParameterivCHROMIUM)},
+    {"glGetPathParameterivCHROMIUMContextANGLE", P(gl::GetPathParameterivCHROMIUMContextANGLE)},
+    {"glGetPointerv", P(gl::GetPointerv)},
+    {"glGetPointervContextANGLE", P(gl::GetPointervContextANGLE)},
+    {"glGetPointervKHR", P(gl::GetPointervKHR)},
+    {"glGetPointervKHRContextANGLE", P(gl::GetPointervKHRContextANGLE)},
+    {"glGetPointervRobustANGLERobustANGLE", P(gl::GetPointervRobustANGLERobustANGLE)},
+    {"glGetPointervRobustANGLERobustANGLEContextANGLE",
+     P(gl::GetPointervRobustANGLERobustANGLEContextANGLE)},
+    {"glGetProgramBinary", P(gl::GetProgramBinary)},
+    {"glGetProgramBinaryContextANGLE", P(gl::GetProgramBinaryContextANGLE)},
+    {"glGetProgramBinaryOES", P(gl::GetProgramBinaryOES)},
+    {"glGetProgramBinaryOESContextANGLE", P(gl::GetProgramBinaryOESContextANGLE)},
+    {"glGetProgramInfoLog", P(gl::GetProgramInfoLog)},
+    {"glGetProgramInfoLogContextANGLE", P(gl::GetProgramInfoLogContextANGLE)},
+    {"glGetProgramInterfaceiv", P(gl::GetProgramInterfaceiv)},
+    {"glGetProgramInterfaceivContextANGLE", P(gl::GetProgramInterfaceivContextANGLE)},
+    {"glGetProgramInterfaceivRobustANGLE", P(gl::GetProgramInterfaceivRobustANGLE)},
+    {"glGetProgramInterfaceivRobustANGLEContextANGLE",
+     P(gl::GetProgramInterfaceivRobustANGLEContextANGLE)},
+    {"glGetProgramPipelineInfoLog", P(gl::GetProgramPipelineInfoLog)},
+    {"glGetProgramPipelineInfoLogContextANGLE", P(gl::GetProgramPipelineInfoLogContextANGLE)},
+    {"glGetProgramPipelineiv", P(gl::GetProgramPipelineiv)},
+    {"glGetProgramPipelineivContextANGLE", P(gl::GetProgramPipelineivContextANGLE)},
+    {"glGetProgramResourceIndex", P(gl::GetProgramResourceIndex)},
+    {"glGetProgramResourceIndexContextANGLE", P(gl::GetProgramResourceIndexContextANGLE)},
+    {"glGetProgramResourceLocation", P(gl::GetProgramResourceLocation)},
+    {"glGetProgramResourceLocationContextANGLE", P(gl::GetProgramResourceLocationContextANGLE)},
+    {"glGetProgramResourceLocationIndexEXT", P(gl::GetProgramResourceLocationIndexEXT)},
+    {"glGetProgramResourceLocationIndexEXTContextANGLE",
+     P(gl::GetProgramResourceLocationIndexEXTContextANGLE)},
+    {"glGetProgramResourceName", P(gl::GetProgramResourceName)},
+    {"glGetProgramResourceNameContextANGLE", P(gl::GetProgramResourceNameContextANGLE)},
+    {"glGetProgramResourceiv", P(gl::GetProgramResourceiv)},
+    {"glGetProgramResourceivContextANGLE", P(gl::GetProgramResourceivContextANGLE)},
+    {"glGetProgramiv", P(gl::GetProgramiv)},
+    {"glGetProgramivContextANGLE", P(gl::GetProgramivContextANGLE)},
+    {"glGetProgramivRobustANGLE", P(gl::GetProgramivRobustANGLE)},
+    {"glGetProgramivRobustANGLEContextANGLE", P(gl::GetProgramivRobustANGLEContextANGLE)},
+    {"glGetQueryObjecti64vEXT", P(gl::GetQueryObjecti64vEXT)},
+    {"glGetQueryObjecti64vEXTContextANGLE", P(gl::GetQueryObjecti64vEXTContextANGLE)},
+    {"glGetQueryObjecti64vRobustANGLE", P(gl::GetQueryObjecti64vRobustANGLE)},
+    {"glGetQueryObjecti64vRobustANGLEContextANGLE",
+     P(gl::GetQueryObjecti64vRobustANGLEContextANGLE)},
+    {"glGetQueryObjectivEXT", P(gl::GetQueryObjectivEXT)},
+    {"glGetQueryObjectivEXTContextANGLE", P(gl::GetQueryObjectivEXTContextANGLE)},
+    {"glGetQueryObjectivRobustANGLE", P(gl::GetQueryObjectivRobustANGLE)},
+    {"glGetQueryObjectivRobustANGLEContextANGLE", P(gl::GetQueryObjectivRobustANGLEContextANGLE)},
+    {"glGetQueryObjectui64vEXT", P(gl::GetQueryObjectui64vEXT)},
+    {"glGetQueryObjectui64vEXTContextANGLE", P(gl::GetQueryObjectui64vEXTContextANGLE)},
+    {"glGetQueryObjectui64vRobustANGLE", P(gl::GetQueryObjectui64vRobustANGLE)},
+    {"glGetQueryObjectui64vRobustANGLEContextANGLE",
+     P(gl::GetQueryObjectui64vRobustANGLEContextANGLE)},
+    {"glGetQueryObjectuiv", P(gl::GetQueryObjectuiv)},
+    {"glGetQueryObjectuivContextANGLE", P(gl::GetQueryObjectuivContextANGLE)},
+    {"glGetQueryObjectuivEXT", P(gl::GetQueryObjectuivEXT)},
+    {"glGetQueryObjectuivEXTContextANGLE", P(gl::GetQueryObjectuivEXTContextANGLE)},
+    {"glGetQueryObjectuivRobustANGLE", P(gl::GetQueryObjectuivRobustANGLE)},
+    {"glGetQueryObjectuivRobustANGLEContextANGLE", P(gl::GetQueryObjectuivRobustANGLEContextANGLE)},
+    {"glGetQueryiv", P(gl::GetQueryiv)},
+    {"glGetQueryivContextANGLE", P(gl::GetQueryivContextANGLE)},
+    {"glGetQueryivEXT", P(gl::GetQueryivEXT)},
+    {"glGetQueryivEXTContextANGLE", P(gl::GetQueryivEXTContextANGLE)},
+    {"glGetQueryivRobustANGLE", P(gl::GetQueryivRobustANGLE)},
+    {"glGetQueryivRobustANGLEContextANGLE", P(gl::GetQueryivRobustANGLEContextANGLE)},
+    {"glGetRenderbufferParameteriv", P(gl::GetRenderbufferParameteriv)},
+    {"glGetRenderbufferParameterivContextANGLE", P(gl::GetRenderbufferParameterivContextANGLE)},
+    {"glGetRenderbufferParameterivOES", P(gl::GetRenderbufferParameterivOES)},
+    {"glGetRenderbufferParameterivOESContextANGLE",
+     P(gl::GetRenderbufferParameterivOESContextANGLE)},
+    {"glGetRenderbufferParameterivRobustANGLE", P(gl::GetRenderbufferParameterivRobustANGLE)},
+    {"glGetRenderbufferParameterivRobustANGLEContextANGLE",
+     P(gl::GetRenderbufferParameterivRobustANGLEContextANGLE)},
+    {"glGetSamplerParameterIivOES", P(gl::GetSamplerParameterIivOES)},
+    {"glGetSamplerParameterIivOESContextANGLE", P(gl::GetSamplerParameterIivOESContextANGLE)},
+    {"glGetSamplerParameterIivRobustANGLE", P(gl::GetSamplerParameterIivRobustANGLE)},
+    {"glGetSamplerParameterIivRobustANGLEContextANGLE",
+     P(gl::GetSamplerParameterIivRobustANGLEContextANGLE)},
+    {"glGetSamplerParameterIuivOES", P(gl::GetSamplerParameterIuivOES)},
+    {"glGetSamplerParameterIuivOESContextANGLE", P(gl::GetSamplerParameterIuivOESContextANGLE)},
+    {"glGetSamplerParameterIuivRobustANGLE", P(gl::GetSamplerParameterIuivRobustANGLE)},
+    {"glGetSamplerParameterIuivRobustANGLEContextANGLE",
+     P(gl::GetSamplerParameterIuivRobustANGLEContextANGLE)},
+    {"glGetSamplerParameterfv", P(gl::GetSamplerParameterfv)},
+    {"glGetSamplerParameterfvContextANGLE", P(gl::GetSamplerParameterfvContextANGLE)},
+    {"glGetSamplerParameterfvRobustANGLE", P(gl::GetSamplerParameterfvRobustANGLE)},
+    {"glGetSamplerParameterfvRobustANGLEContextANGLE",
+     P(gl::GetSamplerParameterfvRobustANGLEContextANGLE)},
+    {"glGetSamplerParameteriv", P(gl::GetSamplerParameteriv)},
+    {"glGetSamplerParameterivContextANGLE", P(gl::GetSamplerParameterivContextANGLE)},
+    {"glGetSamplerParameterivRobustANGLE", P(gl::GetSamplerParameterivRobustANGLE)},
+    {"glGetSamplerParameterivRobustANGLEContextANGLE",
+     P(gl::GetSamplerParameterivRobustANGLEContextANGLE)},
+    {"glGetSemaphoreParameterui64vEXT", P(gl::GetSemaphoreParameterui64vEXT)},
+    {"glGetSemaphoreParameterui64vEXTContextANGLE",
+     P(gl::GetSemaphoreParameterui64vEXTContextANGLE)},
+    {"glGetShaderInfoLog", P(gl::GetShaderInfoLog)},
+    {"glGetShaderInfoLogContextANGLE", P(gl::GetShaderInfoLogContextANGLE)},
+    {"glGetShaderPrecisionFormat", P(gl::GetShaderPrecisionFormat)},
+    {"glGetShaderPrecisionFormatContextANGLE", P(gl::GetShaderPrecisionFormatContextANGLE)},
+    {"glGetShaderSource", P(gl::GetShaderSource)},
+    {"glGetShaderSourceContextANGLE", P(gl::GetShaderSourceContextANGLE)},
+    {"glGetShaderiv", P(gl::GetShaderiv)},
+    {"glGetShaderivContextANGLE", P(gl::GetShaderivContextANGLE)},
+    {"glGetShaderivRobustANGLE", P(gl::GetShaderivRobustANGLE)},
+    {"glGetShaderivRobustANGLEContextANGLE", P(gl::GetShaderivRobustANGLEContextANGLE)},
+    {"glGetString", P(gl::GetString)},
+    {"glGetStringContextANGLE", P(gl::GetStringContextANGLE)},
+    {"glGetStringi", P(gl::GetStringi)},
+    {"glGetStringiContextANGLE", P(gl::GetStringiContextANGLE)},
+    {"glGetSynciv", P(gl::GetSynciv)},
+    {"glGetSyncivContextANGLE", P(gl::GetSyncivContextANGLE)},
+    {"glGetTexEnvfv", P(gl::GetTexEnvfv)},
+    {"glGetTexEnvfvContextANGLE", P(gl::GetTexEnvfvContextANGLE)},
+    {"glGetTexEnviv", P(gl::GetTexEnviv)},
+    {"glGetTexEnvivContextANGLE", P(gl::GetTexEnvivContextANGLE)},
+    {"glGetTexEnvxv", P(gl::GetTexEnvxv)},
+    {"glGetTexEnvxvContextANGLE", P(gl::GetTexEnvxvContextANGLE)},
+    {"glGetTexGenfvOES", P(gl::GetTexGenfvOES)},
+    {"glGetTexGenfvOESContextANGLE", P(gl::GetTexGenfvOESContextANGLE)},
+    {"glGetTexGenivOES", P(gl::GetTexGenivOES)},
+    {"glGetTexGenivOESContextANGLE", P(gl::GetTexGenivOESContextANGLE)},
+    {"glGetTexGenxvOES", P(gl::GetTexGenxvOES)},
+    {"glGetTexGenxvOESContextANGLE", P(gl::GetTexGenxvOESContextANGLE)},
+    {"glGetTexLevelParameterfv", P(gl::GetTexLevelParameterfv)},
+    {"glGetTexLevelParameterfvANGLE", P(gl::GetTexLevelParameterfvANGLE)},
+    {"glGetTexLevelParameterfvANGLEContextANGLE", P(gl::GetTexLevelParameterfvANGLEContextANGLE)},
+    {"glGetTexLevelParameterfvContextANGLE", P(gl::GetTexLevelParameterfvContextANGLE)},
+    {"glGetTexLevelParameterfvRobustANGLE", P(gl::GetTexLevelParameterfvRobustANGLE)},
+    {"glGetTexLevelParameterfvRobustANGLEContextANGLE",
+     P(gl::GetTexLevelParameterfvRobustANGLEContextANGLE)},
+    {"glGetTexLevelParameteriv", P(gl::GetTexLevelParameteriv)},
+    {"glGetTexLevelParameterivANGLE", P(gl::GetTexLevelParameterivANGLE)},
+    {"glGetTexLevelParameterivANGLEContextANGLE", P(gl::GetTexLevelParameterivANGLEContextANGLE)},
+    {"glGetTexLevelParameterivContextANGLE", P(gl::GetTexLevelParameterivContextANGLE)},
+    {"glGetTexLevelParameterivRobustANGLE", P(gl::GetTexLevelParameterivRobustANGLE)},
+    {"glGetTexLevelParameterivRobustANGLEContextANGLE",
+     P(gl::GetTexLevelParameterivRobustANGLEContextANGLE)},
+    {"glGetTexParameterIivOES", P(gl::GetTexParameterIivOES)},
+    {"glGetTexParameterIivOESContextANGLE", P(gl::GetTexParameterIivOESContextANGLE)},
+    {"glGetTexParameterIivRobustANGLE", P(gl::GetTexParameterIivRobustANGLE)},
+    {"glGetTexParameterIivRobustANGLEContextANGLE",
+     P(gl::GetTexParameterIivRobustANGLEContextANGLE)},
+    {"glGetTexParameterIuivOES", P(gl::GetTexParameterIuivOES)},
+    {"glGetTexParameterIuivOESContextANGLE", P(gl::GetTexParameterIuivOESContextANGLE)},
+    {"glGetTexParameterIuivRobustANGLE", P(gl::GetTexParameterIuivRobustANGLE)},
+    {"glGetTexParameterIuivRobustANGLEContextANGLE",
+     P(gl::GetTexParameterIuivRobustANGLEContextANGLE)},
+    {"glGetTexParameterfv", P(gl::GetTexParameterfv)},
+    {"glGetTexParameterfvContextANGLE", P(gl::GetTexParameterfvContextANGLE)},
+    {"glGetTexParameterfvRobustANGLE", P(gl::GetTexParameterfvRobustANGLE)},
+    {"glGetTexParameterfvRobustANGLEContextANGLE", P(gl::GetTexParameterfvRobustANGLEContextANGLE)},
+    {"glGetTexParameteriv", P(gl::GetTexParameteriv)},
+    {"glGetTexParameterivContextANGLE", P(gl::GetTexParameterivContextANGLE)},
+    {"glGetTexParameterivRobustANGLE", P(gl::GetTexParameterivRobustANGLE)},
+    {"glGetTexParameterivRobustANGLEContextANGLE", P(gl::GetTexParameterivRobustANGLEContextANGLE)},
+    {"glGetTexParameterxv", P(gl::GetTexParameterxv)},
+    {"glGetTexParameterxvContextANGLE", P(gl::GetTexParameterxvContextANGLE)},
+    {"glGetTransformFeedbackVarying", P(gl::GetTransformFeedbackVarying)},
+    {"glGetTransformFeedbackVaryingContextANGLE", P(gl::GetTransformFeedbackVaryingContextANGLE)},
+    {"glGetTranslatedShaderSourceANGLE", P(gl::GetTranslatedShaderSourceANGLE)},
+    {"glGetTranslatedShaderSourceANGLEContextANGLE",
+     P(gl::GetTranslatedShaderSourceANGLEContextANGLE)},
+    {"glGetUniformBlockIndex", P(gl::GetUniformBlockIndex)},
+    {"glGetUniformBlockIndexContextANGLE", P(gl::GetUniformBlockIndexContextANGLE)},
+    {"glGetUniformIndices", P(gl::GetUniformIndices)},
+    {"glGetUniformIndicesContextANGLE", P(gl::GetUniformIndicesContextANGLE)},
+    {"glGetUniformLocation", P(gl::GetUniformLocation)},
+    {"glGetUniformLocationContextANGLE", P(gl::GetUniformLocationContextANGLE)},
+    {"glGetUniformfv", P(gl::GetUniformfv)},
+    {"glGetUniformfvContextANGLE", P(gl::GetUniformfvContextANGLE)},
+    {"glGetUniformfvRobustANGLE", P(gl::GetUniformfvRobustANGLE)},
+    {"glGetUniformfvRobustANGLEContextANGLE", P(gl::GetUniformfvRobustANGLEContextANGLE)},
+    {"glGetUniformiv", P(gl::GetUniformiv)},
+    {"glGetUniformivContextANGLE", P(gl::GetUniformivContextANGLE)},
+    {"glGetUniformivRobustANGLE", P(gl::GetUniformivRobustANGLE)},
+    {"glGetUniformivRobustANGLEContextANGLE", P(gl::GetUniformivRobustANGLEContextANGLE)},
+    {"glGetUniformuiv", P(gl::GetUniformuiv)},
+    {"glGetUniformuivContextANGLE", P(gl::GetUniformuivContextANGLE)},
+    {"glGetUniformuivRobustANGLE", P(gl::GetUniformuivRobustANGLE)},
+    {"glGetUniformuivRobustANGLEContextANGLE", P(gl::GetUniformuivRobustANGLEContextANGLE)},
+    {"glGetUnsignedBytei_vEXT", P(gl::GetUnsignedBytei_vEXT)},
+    {"glGetUnsignedBytei_vEXTContextANGLE", P(gl::GetUnsignedBytei_vEXTContextANGLE)},
+    {"glGetUnsignedBytevEXT", P(gl::GetUnsignedBytevEXT)},
+    {"glGetUnsignedBytevEXTContextANGLE", P(gl::GetUnsignedBytevEXTContextANGLE)},
+    {"glGetVertexAttribIiv", P(gl::GetVertexAttribIiv)},
+    {"glGetVertexAttribIivContextANGLE", P(gl::GetVertexAttribIivContextANGLE)},
+    {"glGetVertexAttribIivRobustANGLE", P(gl::GetVertexAttribIivRobustANGLE)},
+    {"glGetVertexAttribIivRobustANGLEContextANGLE",
+     P(gl::GetVertexAttribIivRobustANGLEContextANGLE)},
+    {"glGetVertexAttribIuiv", P(gl::GetVertexAttribIuiv)},
+    {"glGetVertexAttribIuivContextANGLE", P(gl::GetVertexAttribIuivContextANGLE)},
+    {"glGetVertexAttribIuivRobustANGLE", P(gl::GetVertexAttribIuivRobustANGLE)},
+    {"glGetVertexAttribIuivRobustANGLEContextANGLE",
+     P(gl::GetVertexAttribIuivRobustANGLEContextANGLE)},
+    {"glGetVertexAttribPointerv", P(gl::GetVertexAttribPointerv)},
+    {"glGetVertexAttribPointervContextANGLE", P(gl::GetVertexAttribPointervContextANGLE)},
+    {"glGetVertexAttribPointervRobustANGLE", P(gl::GetVertexAttribPointervRobustANGLE)},
+    {"glGetVertexAttribPointervRobustANGLEContextANGLE",
+     P(gl::GetVertexAttribPointervRobustANGLEContextANGLE)},
+    {"glGetVertexAttribfv", P(gl::GetVertexAttribfv)},
+    {"glGetVertexAttribfvContextANGLE", P(gl::GetVertexAttribfvContextANGLE)},
+    {"glGetVertexAttribfvRobustANGLE", P(gl::GetVertexAttribfvRobustANGLE)},
+    {"glGetVertexAttribfvRobustANGLEContextANGLE", P(gl::GetVertexAttribfvRobustANGLEContextANGLE)},
+    {"glGetVertexAttribiv", P(gl::GetVertexAttribiv)},
+    {"glGetVertexAttribivContextANGLE", P(gl::GetVertexAttribivContextANGLE)},
+    {"glGetVertexAttribivRobustANGLE", P(gl::GetVertexAttribivRobustANGLE)},
+    {"glGetVertexAttribivRobustANGLEContextANGLE", P(gl::GetVertexAttribivRobustANGLEContextANGLE)},
+    {"glGetnUniformfvEXT", P(gl::GetnUniformfvEXT)},
+    {"glGetnUniformfvEXTContextANGLE", P(gl::GetnUniformfvEXTContextANGLE)},
+    {"glGetnUniformfvRobustANGLE", P(gl::GetnUniformfvRobustANGLE)},
+    {"glGetnUniformfvRobustANGLEContextANGLE", P(gl::GetnUniformfvRobustANGLEContextANGLE)},
+    {"glGetnUniformivEXT", P(gl::GetnUniformivEXT)},
+    {"glGetnUniformivEXTContextANGLE", P(gl::GetnUniformivEXTContextANGLE)},
+    {"glGetnUniformivRobustANGLE", P(gl::GetnUniformivRobustANGLE)},
+    {"glGetnUniformivRobustANGLEContextANGLE", P(gl::GetnUniformivRobustANGLEContextANGLE)},
+    {"glGetnUniformuivRobustANGLE", P(gl::GetnUniformuivRobustANGLE)},
+    {"glGetnUniformuivRobustANGLEContextANGLE", P(gl::GetnUniformuivRobustANGLEContextANGLE)},
+    {"glHint", P(gl::Hint)},
+    {"glHintContextANGLE", P(gl::HintContextANGLE)},
+    {"glImportMemoryFdEXT", P(gl::ImportMemoryFdEXT)},
+    {"glImportMemoryFdEXTContextANGLE", P(gl::ImportMemoryFdEXTContextANGLE)},
+    {"glImportSemaphoreFdEXT", P(gl::ImportSemaphoreFdEXT)},
+    {"glImportSemaphoreFdEXTContextANGLE", P(gl::ImportSemaphoreFdEXTContextANGLE)},
+    {"glInsertEventMarkerEXT", P(gl::InsertEventMarkerEXT)},
+    {"glInsertEventMarkerEXTContextANGLE", P(gl::InsertEventMarkerEXTContextANGLE)},
+    {"glInvalidateFramebuffer", P(gl::InvalidateFramebuffer)},
+    {"glInvalidateFramebufferContextANGLE", P(gl::InvalidateFramebufferContextANGLE)},
+    {"glInvalidateSubFramebuffer", P(gl::InvalidateSubFramebuffer)},
+    {"glInvalidateSubFramebufferContextANGLE", P(gl::InvalidateSubFramebufferContextANGLE)},
+    {"glInvalidateTextureANGLE", P(gl::InvalidateTextureANGLE)},
+    {"glInvalidateTextureANGLEContextANGLE", P(gl::InvalidateTextureANGLEContextANGLE)},
+    {"glIsBuffer", P(gl::IsBuffer)},
+    {"glIsBufferContextANGLE", P(gl::IsBufferContextANGLE)},
+    {"glIsEnabled", P(gl::IsEnabled)},
+    {"glIsEnabledContextANGLE", P(gl::IsEnabledContextANGLE)},
+    {"glIsFenceNV", P(gl::IsFenceNV)},
+    {"glIsFenceNVContextANGLE", P(gl::IsFenceNVContextANGLE)},
+    {"glIsFramebuffer", P(gl::IsFramebuffer)},
+    {"glIsFramebufferContextANGLE", P(gl::IsFramebufferContextANGLE)},
+    {"glIsFramebufferOES", P(gl::IsFramebufferOES)},
+    {"glIsFramebufferOESContextANGLE", P(gl::IsFramebufferOESContextANGLE)},
+    {"glIsMemoryObjectEXT", P(gl::IsMemoryObjectEXT)},
+    {"glIsMemoryObjectEXTContextANGLE", P(gl::IsMemoryObjectEXTContextANGLE)},
+    {"glIsPathCHROMIUM", P(gl::IsPathCHROMIUM)},
+    {"glIsPathCHROMIUMContextANGLE", P(gl::IsPathCHROMIUMContextANGLE)},
+    {"glIsProgram", P(gl::IsProgram)},
+    {"glIsProgramContextANGLE", P(gl::IsProgramContextANGLE)},
+    {"glIsProgramPipeline", P(gl::IsProgramPipeline)},
+    {"glIsProgramPipelineContextANGLE", P(gl::IsProgramPipelineContextANGLE)},
+    {"glIsQuery", P(gl::IsQuery)},
+    {"glIsQueryContextANGLE", P(gl::IsQueryContextANGLE)},
+    {"glIsQueryEXT", P(gl::IsQueryEXT)},
+    {"glIsQueryEXTContextANGLE", P(gl::IsQueryEXTContextANGLE)},
+    {"glIsRenderbuffer", P(gl::IsRenderbuffer)},
+    {"glIsRenderbufferContextANGLE", P(gl::IsRenderbufferContextANGLE)},
+    {"glIsRenderbufferOES", P(gl::IsRenderbufferOES)},
+    {"glIsRenderbufferOESContextANGLE", P(gl::IsRenderbufferOESContextANGLE)},
+    {"glIsSampler", P(gl::IsSampler)},
+    {"glIsSamplerContextANGLE", P(gl::IsSamplerContextANGLE)},
+    {"glIsSemaphoreEXT", P(gl::IsSemaphoreEXT)},
+    {"glIsSemaphoreEXTContextANGLE", P(gl::IsSemaphoreEXTContextANGLE)},
+    {"glIsShader", P(gl::IsShader)},
+    {"glIsShaderContextANGLE", P(gl::IsShaderContextANGLE)},
+    {"glIsSync", P(gl::IsSync)},
+    {"glIsSyncContextANGLE", P(gl::IsSyncContextANGLE)},
+    {"glIsTexture", P(gl::IsTexture)},
+    {"glIsTextureContextANGLE", P(gl::IsTextureContextANGLE)},
+    {"glIsTransformFeedback", P(gl::IsTransformFeedback)},
+    {"glIsTransformFeedbackContextANGLE", P(gl::IsTransformFeedbackContextANGLE)},
+    {"glIsVertexArray", P(gl::IsVertexArray)},
+    {"glIsVertexArrayContextANGLE", P(gl::IsVertexArrayContextANGLE)},
+    {"glIsVertexArrayOES", P(gl::IsVertexArrayOES)},
+    {"glIsVertexArrayOESContextANGLE", P(gl::IsVertexArrayOESContextANGLE)},
+    {"glLightModelf", P(gl::LightModelf)},
+    {"glLightModelfContextANGLE", P(gl::LightModelfContextANGLE)},
+    {"glLightModelfv", P(gl::LightModelfv)},
+    {"glLightModelfvContextANGLE", P(gl::LightModelfvContextANGLE)},
+    {"glLightModelx", P(gl::LightModelx)},
+    {"glLightModelxContextANGLE", P(gl::LightModelxContextANGLE)},
+    {"glLightModelxv", P(gl::LightModelxv)},
+    {"glLightModelxvContextANGLE", P(gl::LightModelxvContextANGLE)},
+    {"glLightf", P(gl::Lightf)},
+    {"glLightfContextANGLE", P(gl::LightfContextANGLE)},
+    {"glLightfv", P(gl::Lightfv)},
+    {"glLightfvContextANGLE", P(gl::LightfvContextANGLE)},
+    {"glLightx", P(gl::Lightx)},
+    {"glLightxContextANGLE", P(gl::LightxContextANGLE)},
+    {"glLightxv", P(gl::Lightxv)},
+    {"glLightxvContextANGLE", P(gl::LightxvContextANGLE)},
+    {"glLineWidth", P(gl::LineWidth)},
+    {"glLineWidthContextANGLE", P(gl::LineWidthContextANGLE)},
+    {"glLineWidthx", P(gl::LineWidthx)},
+    {"glLineWidthxContextANGLE", P(gl::LineWidthxContextANGLE)},
+    {"glLinkProgram", P(gl::LinkProgram)},
+    {"glLinkProgramContextANGLE", P(gl::LinkProgramContextANGLE)},
+    {"glLoadIdentity", P(gl::LoadIdentity)},
+    {"glLoadIdentityContextANGLE", P(gl::LoadIdentityContextANGLE)},
+    {"glLoadMatrixf", P(gl::LoadMatrixf)},
+    {"glLoadMatrixfContextANGLE", P(gl::LoadMatrixfContextANGLE)},
+    {"glLoadMatrixx", P(gl::LoadMatrixx)},
+    {"glLoadMatrixxContextANGLE", P(gl::LoadMatrixxContextANGLE)},
+    {"glLoadPaletteFromModelViewMatrixOES", P(gl::LoadPaletteFromModelViewMatrixOES)},
+    {"glLoadPaletteFromModelViewMatrixOESContextANGLE",
+     P(gl::LoadPaletteFromModelViewMatrixOESContextANGLE)},
+    {"glLogicOp", P(gl::LogicOp)},
+    {"glLogicOpContextANGLE", P(gl::LogicOpContextANGLE)},
+    {"glLoseContextCHROMIUM", P(gl::LoseContextCHROMIUM)},
+    {"glLoseContextCHROMIUMContextANGLE", P(gl::LoseContextCHROMIUMContextANGLE)},
+    {"glMapBufferOES", P(gl::MapBufferOES)},
+    {"glMapBufferOESContextANGLE", P(gl::MapBufferOESContextANGLE)},
+    {"glMapBufferRange", P(gl::MapBufferRange)},
+    {"glMapBufferRangeContextANGLE", P(gl::MapBufferRangeContextANGLE)},
+    {"glMapBufferRangeEXT", P(gl::MapBufferRangeEXT)},
+    {"glMapBufferRangeEXTContextANGLE", P(gl::MapBufferRangeEXTContextANGLE)},
+    {"glMaterialf", P(gl::Materialf)},
+    {"glMaterialfContextANGLE", P(gl::MaterialfContextANGLE)},
+    {"glMaterialfv", P(gl::Materialfv)},
+    {"glMaterialfvContextANGLE", P(gl::MaterialfvContextANGLE)},
+    {"glMaterialx", P(gl::Materialx)},
+    {"glMaterialxContextANGLE", P(gl::MaterialxContextANGLE)},
+    {"glMaterialxv", P(gl::Materialxv)},
+    {"glMaterialxvContextANGLE", P(gl::MaterialxvContextANGLE)},
+    {"glMatrixIndexPointerOES", P(gl::MatrixIndexPointerOES)},
+    {"glMatrixIndexPointerOESContextANGLE", P(gl::MatrixIndexPointerOESContextANGLE)},
+    {"glMatrixLoadIdentityCHROMIUM", P(gl::MatrixLoadIdentityCHROMIUM)},
+    {"glMatrixLoadIdentityCHROMIUMContextANGLE", P(gl::MatrixLoadIdentityCHROMIUMContextANGLE)},
+    {"glMatrixLoadfCHROMIUM", P(gl::MatrixLoadfCHROMIUM)},
+    {"glMatrixLoadfCHROMIUMContextANGLE", P(gl::MatrixLoadfCHROMIUMContextANGLE)},
+    {"glMatrixMode", P(gl::MatrixMode)},
+    {"glMatrixModeContextANGLE", P(gl::MatrixModeContextANGLE)},
+    {"glMaxShaderCompilerThreadsKHR", P(gl::MaxShaderCompilerThreadsKHR)},
+    {"glMaxShaderCompilerThreadsKHRContextANGLE", P(gl::MaxShaderCompilerThreadsKHRContextANGLE)},
+    {"glMemoryBarrier", P(gl::MemoryBarrier)},
+    {"glMemoryBarrierByRegion", P(gl::MemoryBarrierByRegion)},
+    {"glMemoryBarrierByRegionContextANGLE", P(gl::MemoryBarrierByRegionContextANGLE)},
+    {"glMemoryBarrierContextANGLE", P(gl::MemoryBarrierContextANGLE)},
+    {"glMemoryObjectParameterivEXT", P(gl::MemoryObjectParameterivEXT)},
+    {"glMemoryObjectParameterivEXTContextANGLE", P(gl::MemoryObjectParameterivEXTContextANGLE)},
+    {"glMultMatrixf", P(gl::MultMatrixf)},
+    {"glMultMatrixfContextANGLE", P(gl::MultMatrixfContextANGLE)},
+    {"glMultMatrixx", P(gl::MultMatrixx)},
+    {"glMultMatrixxContextANGLE", P(gl::MultMatrixxContextANGLE)},
+    {"glMultiDrawArraysANGLE", P(gl::MultiDrawArraysANGLE)},
+    {"glMultiDrawArraysANGLEContextANGLE", P(gl::MultiDrawArraysANGLEContextANGLE)},
+    {"glMultiDrawArraysInstancedANGLE", P(gl::MultiDrawArraysInstancedANGLE)},
+    {"glMultiDrawArraysInstancedANGLEContextANGLE",
+     P(gl::MultiDrawArraysInstancedANGLEContextANGLE)},
+    {"glMultiDrawElementsANGLE", P(gl::MultiDrawElementsANGLE)},
+    {"glMultiDrawElementsANGLEContextANGLE", P(gl::MultiDrawElementsANGLEContextANGLE)},
+    {"glMultiDrawElementsInstancedANGLE", P(gl::MultiDrawElementsInstancedANGLE)},
+    {"glMultiDrawElementsInstancedANGLEContextANGLE",
+     P(gl::MultiDrawElementsInstancedANGLEContextANGLE)},
+    {"glMultiTexCoord4f", P(gl::MultiTexCoord4f)},
+    {"glMultiTexCoord4fContextANGLE", P(gl::MultiTexCoord4fContextANGLE)},
+    {"glMultiTexCoord4x", P(gl::MultiTexCoord4x)},
+    {"glMultiTexCoord4xContextANGLE", P(gl::MultiTexCoord4xContextANGLE)},
+    {"glNormal3f", P(gl::Normal3f)},
+    {"glNormal3fContextANGLE", P(gl::Normal3fContextANGLE)},
+    {"glNormal3x", P(gl::Normal3x)},
+    {"glNormal3xContextANGLE", P(gl::Normal3xContextANGLE)},
+    {"glNormalPointer", P(gl::NormalPointer)},
+    {"glNormalPointerContextANGLE", P(gl::NormalPointerContextANGLE)},
+    {"glObjectLabelKHR", P(gl::ObjectLabelKHR)},
+    {"glObjectLabelKHRContextANGLE", P(gl::ObjectLabelKHRContextANGLE)},
+    {"glObjectPtrLabelKHR", P(gl::ObjectPtrLabelKHR)},
+    {"glObjectPtrLabelKHRContextANGLE", P(gl::ObjectPtrLabelKHRContextANGLE)},
+    {"glOrthof", P(gl::Orthof)},
+    {"glOrthofContextANGLE", P(gl::OrthofContextANGLE)},
+    {"glOrthox", P(gl::Orthox)},
+    {"glOrthoxContextANGLE", P(gl::OrthoxContextANGLE)},
+    {"glPathCommandsCHROMIUM", P(gl::PathCommandsCHROMIUM)},
+    {"glPathCommandsCHROMIUMContextANGLE", P(gl::PathCommandsCHROMIUMContextANGLE)},
+    {"glPathParameterfCHROMIUM", P(gl::PathParameterfCHROMIUM)},
+    {"glPathParameterfCHROMIUMContextANGLE", P(gl::PathParameterfCHROMIUMContextANGLE)},
+    {"glPathParameteriCHROMIUM", P(gl::PathParameteriCHROMIUM)},
+    {"glPathParameteriCHROMIUMContextANGLE", P(gl::PathParameteriCHROMIUMContextANGLE)},
+    {"glPathStencilFuncCHROMIUM", P(gl::PathStencilFuncCHROMIUM)},
+    {"glPathStencilFuncCHROMIUMContextANGLE", P(gl::PathStencilFuncCHROMIUMContextANGLE)},
+    {"glPauseTransformFeedback", P(gl::PauseTransformFeedback)},
+    {"glPauseTransformFeedbackContextANGLE", P(gl::PauseTransformFeedbackContextANGLE)},
+    {"glPixelStorei", P(gl::PixelStorei)},
+    {"glPixelStoreiContextANGLE", P(gl::PixelStoreiContextANGLE)},
+    {"glPointParameterf", P(gl::PointParameterf)},
+    {"glPointParameterfContextANGLE", P(gl::PointParameterfContextANGLE)},
+    {"glPointParameterfv", P(gl::PointParameterfv)},
+    {"glPointParameterfvContextANGLE", P(gl::PointParameterfvContextANGLE)},
+    {"glPointParameterx", P(gl::PointParameterx)},
+    {"glPointParameterxContextANGLE", P(gl::PointParameterxContextANGLE)},
+    {"glPointParameterxv", P(gl::PointParameterxv)},
+    {"glPointParameterxvContextANGLE", P(gl::PointParameterxvContextANGLE)},
+    {"glPointSize", P(gl::PointSize)},
+    {"glPointSizeContextANGLE", P(gl::PointSizeContextANGLE)},
+    {"glPointSizePointerOES", P(gl::PointSizePointerOES)},
+    {"glPointSizePointerOESContextANGLE", P(gl::PointSizePointerOESContextANGLE)},
+    {"glPointSizex", P(gl::PointSizex)},
+    {"glPointSizexContextANGLE", P(gl::PointSizexContextANGLE)},
+    {"glPolygonOffset", P(gl::PolygonOffset)},
+    {"glPolygonOffsetContextANGLE", P(gl::PolygonOffsetContextANGLE)},
+    {"glPolygonOffsetx", P(gl::PolygonOffsetx)},
+    {"glPolygonOffsetxContextANGLE", P(gl::PolygonOffsetxContextANGLE)},
+    {"glPopDebugGroupKHR", P(gl::PopDebugGroupKHR)},
+    {"glPopDebugGroupKHRContextANGLE", P(gl::PopDebugGroupKHRContextANGLE)},
+    {"glPopGroupMarkerEXT", P(gl::PopGroupMarkerEXT)},
+    {"glPopGroupMarkerEXTContextANGLE", P(gl::PopGroupMarkerEXTContextANGLE)},
+    {"glPopMatrix", P(gl::PopMatrix)},
+    {"glPopMatrixContextANGLE", P(gl::PopMatrixContextANGLE)},
+    {"glProgramBinary", P(gl::ProgramBinary)},
+    {"glProgramBinaryContextANGLE", P(gl::ProgramBinaryContextANGLE)},
+    {"glProgramBinaryOES", P(gl::ProgramBinaryOES)},
+    {"glProgramBinaryOESContextANGLE", P(gl::ProgramBinaryOESContextANGLE)},
+    {"glProgramParameteri", P(gl::ProgramParameteri)},
+    {"glProgramParameteriContextANGLE", P(gl::ProgramParameteriContextANGLE)},
+    {"glProgramPathFragmentInputGenCHROMIUM", P(gl::ProgramPathFragmentInputGenCHROMIUM)},
+    {"glProgramPathFragmentInputGenCHROMIUMContextANGLE",
+     P(gl::ProgramPathFragmentInputGenCHROMIUMContextANGLE)},
+    {"glProgramUniform1f", P(gl::ProgramUniform1f)},
+    {"glProgramUniform1fContextANGLE", P(gl::ProgramUniform1fContextANGLE)},
+    {"glProgramUniform1fv", P(gl::ProgramUniform1fv)},
+    {"glProgramUniform1fvContextANGLE", P(gl::ProgramUniform1fvContextANGLE)},
+    {"glProgramUniform1i", P(gl::ProgramUniform1i)},
+    {"glProgramUniform1iContextANGLE", P(gl::ProgramUniform1iContextANGLE)},
+    {"glProgramUniform1iv", P(gl::ProgramUniform1iv)},
+    {"glProgramUniform1ivContextANGLE", P(gl::ProgramUniform1ivContextANGLE)},
+    {"glProgramUniform1ui", P(gl::ProgramUniform1ui)},
+    {"glProgramUniform1uiContextANGLE", P(gl::ProgramUniform1uiContextANGLE)},
+    {"glProgramUniform1uiv", P(gl::ProgramUniform1uiv)},
+    {"glProgramUniform1uivContextANGLE", P(gl::ProgramUniform1uivContextANGLE)},
+    {"glProgramUniform2f", P(gl::ProgramUniform2f)},
+    {"glProgramUniform2fContextANGLE", P(gl::ProgramUniform2fContextANGLE)},
+    {"glProgramUniform2fv", P(gl::ProgramUniform2fv)},
+    {"glProgramUniform2fvContextANGLE", P(gl::ProgramUniform2fvContextANGLE)},
+    {"glProgramUniform2i", P(gl::ProgramUniform2i)},
+    {"glProgramUniform2iContextANGLE", P(gl::ProgramUniform2iContextANGLE)},
+    {"glProgramUniform2iv", P(gl::ProgramUniform2iv)},
+    {"glProgramUniform2ivContextANGLE", P(gl::ProgramUniform2ivContextANGLE)},
+    {"glProgramUniform2ui", P(gl::ProgramUniform2ui)},
+    {"glProgramUniform2uiContextANGLE", P(gl::ProgramUniform2uiContextANGLE)},
+    {"glProgramUniform2uiv", P(gl::ProgramUniform2uiv)},
+    {"glProgramUniform2uivContextANGLE", P(gl::ProgramUniform2uivContextANGLE)},
+    {"glProgramUniform3f", P(gl::ProgramUniform3f)},
+    {"glProgramUniform3fContextANGLE", P(gl::ProgramUniform3fContextANGLE)},
+    {"glProgramUniform3fv", P(gl::ProgramUniform3fv)},
+    {"glProgramUniform3fvContextANGLE", P(gl::ProgramUniform3fvContextANGLE)},
+    {"glProgramUniform3i", P(gl::ProgramUniform3i)},
+    {"glProgramUniform3iContextANGLE", P(gl::ProgramUniform3iContextANGLE)},
+    {"glProgramUniform3iv", P(gl::ProgramUniform3iv)},
+    {"glProgramUniform3ivContextANGLE", P(gl::ProgramUniform3ivContextANGLE)},
+    {"glProgramUniform3ui", P(gl::ProgramUniform3ui)},
+    {"glProgramUniform3uiContextANGLE", P(gl::ProgramUniform3uiContextANGLE)},
+    {"glProgramUniform3uiv", P(gl::ProgramUniform3uiv)},
+    {"glProgramUniform3uivContextANGLE", P(gl::ProgramUniform3uivContextANGLE)},
+    {"glProgramUniform4f", P(gl::ProgramUniform4f)},
+    {"glProgramUniform4fContextANGLE", P(gl::ProgramUniform4fContextANGLE)},
+    {"glProgramUniform4fv", P(gl::ProgramUniform4fv)},
+    {"glProgramUniform4fvContextANGLE", P(gl::ProgramUniform4fvContextANGLE)},
+    {"glProgramUniform4i", P(gl::ProgramUniform4i)},
+    {"glProgramUniform4iContextANGLE", P(gl::ProgramUniform4iContextANGLE)},
+    {"glProgramUniform4iv", P(gl::ProgramUniform4iv)},
+    {"glProgramUniform4ivContextANGLE", P(gl::ProgramUniform4ivContextANGLE)},
+    {"glProgramUniform4ui", P(gl::ProgramUniform4ui)},
+    {"glProgramUniform4uiContextANGLE", P(gl::ProgramUniform4uiContextANGLE)},
+    {"glProgramUniform4uiv", P(gl::ProgramUniform4uiv)},
+    {"glProgramUniform4uivContextANGLE", P(gl::ProgramUniform4uivContextANGLE)},
+    {"glProgramUniformMatrix2fv", P(gl::ProgramUniformMatrix2fv)},
+    {"glProgramUniformMatrix2fvContextANGLE", P(gl::ProgramUniformMatrix2fvContextANGLE)},
+    {"glProgramUniformMatrix2x3fv", P(gl::ProgramUniformMatrix2x3fv)},
+    {"glProgramUniformMatrix2x3fvContextANGLE", P(gl::ProgramUniformMatrix2x3fvContextANGLE)},
+    {"glProgramUniformMatrix2x4fv", P(gl::ProgramUniformMatrix2x4fv)},
+    {"glProgramUniformMatrix2x4fvContextANGLE", P(gl::ProgramUniformMatrix2x4fvContextANGLE)},
+    {"glProgramUniformMatrix3fv", P(gl::ProgramUniformMatrix3fv)},
+    {"glProgramUniformMatrix3fvContextANGLE", P(gl::ProgramUniformMatrix3fvContextANGLE)},
+    {"glProgramUniformMatrix3x2fv", P(gl::ProgramUniformMatrix3x2fv)},
+    {"glProgramUniformMatrix3x2fvContextANGLE", P(gl::ProgramUniformMatrix3x2fvContextANGLE)},
+    {"glProgramUniformMatrix3x4fv", P(gl::ProgramUniformMatrix3x4fv)},
+    {"glProgramUniformMatrix3x4fvContextANGLE", P(gl::ProgramUniformMatrix3x4fvContextANGLE)},
+    {"glProgramUniformMatrix4fv", P(gl::ProgramUniformMatrix4fv)},
+    {"glProgramUniformMatrix4fvContextANGLE", P(gl::ProgramUniformMatrix4fvContextANGLE)},
+    {"glProgramUniformMatrix4x2fv", P(gl::ProgramUniformMatrix4x2fv)},
+    {"glProgramUniformMatrix4x2fvContextANGLE", P(gl::ProgramUniformMatrix4x2fvContextANGLE)},
+    {"glProgramUniformMatrix4x3fv", P(gl::ProgramUniformMatrix4x3fv)},
+    {"glProgramUniformMatrix4x3fvContextANGLE", P(gl::ProgramUniformMatrix4x3fvContextANGLE)},
+    {"glProvokingVertexANGLE", P(gl::ProvokingVertexANGLE)},
+    {"glProvokingVertexANGLEContextANGLE", P(gl::ProvokingVertexANGLEContextANGLE)},
+    {"glPushDebugGroupKHR", P(gl::PushDebugGroupKHR)},
+    {"glPushDebugGroupKHRContextANGLE", P(gl::PushDebugGroupKHRContextANGLE)},
+    {"glPushGroupMarkerEXT", P(gl::PushGroupMarkerEXT)},
+    {"glPushGroupMarkerEXTContextANGLE", P(gl::PushGroupMarkerEXTContextANGLE)},
+    {"glPushMatrix", P(gl::PushMatrix)},
+    {"glPushMatrixContextANGLE", P(gl::PushMatrixContextANGLE)},
+    {"glQueryCounterEXT", P(gl::QueryCounterEXT)},
+    {"glQueryCounterEXTContextANGLE", P(gl::QueryCounterEXTContextANGLE)},
+    {"glQueryMatrixxOES", P(gl::QueryMatrixxOES)},
+    {"glQueryMatrixxOESContextANGLE", P(gl::QueryMatrixxOESContextANGLE)},
+    {"glReadBuffer", P(gl::ReadBuffer)},
+    {"glReadBufferContextANGLE", P(gl::ReadBufferContextANGLE)},
+    {"glReadPixels", P(gl::ReadPixels)},
+    {"glReadPixelsContextANGLE", P(gl::ReadPixelsContextANGLE)},
+    {"glReadPixelsRobustANGLE", P(gl::ReadPixelsRobustANGLE)},
+    {"glReadPixelsRobustANGLEContextANGLE", P(gl::ReadPixelsRobustANGLEContextANGLE)},
+    {"glReadnPixelsEXT", P(gl::ReadnPixelsEXT)},
+    {"glReadnPixelsEXTContextANGLE", P(gl::ReadnPixelsEXTContextANGLE)},
+    {"glReadnPixelsRobustANGLE", P(gl::ReadnPixelsRobustANGLE)},
+    {"glReadnPixelsRobustANGLEContextANGLE", P(gl::ReadnPixelsRobustANGLEContextANGLE)},
+    {"glReleaseShaderCompiler", P(gl::ReleaseShaderCompiler)},
+    {"glReleaseShaderCompilerContextANGLE", P(gl::ReleaseShaderCompilerContextANGLE)},
+    {"glRenderbufferStorage", P(gl::RenderbufferStorage)},
+    {"glRenderbufferStorageContextANGLE", P(gl::RenderbufferStorageContextANGLE)},
+    {"glRenderbufferStorageMultisample", P(gl::RenderbufferStorageMultisample)},
+    {"glRenderbufferStorageMultisampleANGLE", P(gl::RenderbufferStorageMultisampleANGLE)},
+    {"glRenderbufferStorageMultisampleANGLEContextANGLE",
+     P(gl::RenderbufferStorageMultisampleANGLEContextANGLE)},
+    {"glRenderbufferStorageMultisampleContextANGLE",
+     P(gl::RenderbufferStorageMultisampleContextANGLE)},
+    {"glRenderbufferStorageOES", P(gl::RenderbufferStorageOES)},
+    {"glRenderbufferStorageOESContextANGLE", P(gl::RenderbufferStorageOESContextANGLE)},
+    {"glRequestExtensionANGLE", P(gl::RequestExtensionANGLE)},
+    {"glRequestExtensionANGLEContextANGLE", P(gl::RequestExtensionANGLEContextANGLE)},
+    {"glResumeTransformFeedback", P(gl::ResumeTransformFeedback)},
+    {"glResumeTransformFeedbackContextANGLE", P(gl::ResumeTransformFeedbackContextANGLE)},
+    {"glRotatef", P(gl::Rotatef)},
+    {"glRotatefContextANGLE", P(gl::RotatefContextANGLE)},
+    {"glRotatex", P(gl::Rotatex)},
+    {"glRotatexContextANGLE", P(gl::RotatexContextANGLE)},
+    {"glSampleCoverage", P(gl::SampleCoverage)},
+    {"glSampleCoverageContextANGLE", P(gl::SampleCoverageContextANGLE)},
+    {"glSampleCoveragex", P(gl::SampleCoveragex)},
+    {"glSampleCoveragexContextANGLE", P(gl::SampleCoveragexContextANGLE)},
+    {"glSampleMaski", P(gl::SampleMaski)},
+    {"glSampleMaskiANGLE", P(gl::SampleMaskiANGLE)},
+    {"glSampleMaskiANGLEContextANGLE", P(gl::SampleMaskiANGLEContextANGLE)},
+    {"glSampleMaskiContextANGLE", P(gl::SampleMaskiContextANGLE)},
+    {"glSamplerParameterIivOES", P(gl::SamplerParameterIivOES)},
+    {"glSamplerParameterIivOESContextANGLE", P(gl::SamplerParameterIivOESContextANGLE)},
+    {"glSamplerParameterIivRobustANGLE", P(gl::SamplerParameterIivRobustANGLE)},
+    {"glSamplerParameterIivRobustANGLEContextANGLE",
+     P(gl::SamplerParameterIivRobustANGLEContextANGLE)},
+    {"glSamplerParameterIuivOES", P(gl::SamplerParameterIuivOES)},
+    {"glSamplerParameterIuivOESContextANGLE", P(gl::SamplerParameterIuivOESContextANGLE)},
+    {"glSamplerParameterIuivRobustANGLE", P(gl::SamplerParameterIuivRobustANGLE)},
+    {"glSamplerParameterIuivRobustANGLEContextANGLE",
+     P(gl::SamplerParameterIuivRobustANGLEContextANGLE)},
+    {"glSamplerParameterf", P(gl::SamplerParameterf)},
+    {"glSamplerParameterfContextANGLE", P(gl::SamplerParameterfContextANGLE)},
+    {"glSamplerParameterfv", P(gl::SamplerParameterfv)},
+    {"glSamplerParameterfvContextANGLE", P(gl::SamplerParameterfvContextANGLE)},
+    {"glSamplerParameterfvRobustANGLE", P(gl::SamplerParameterfvRobustANGLE)},
+    {"glSamplerParameterfvRobustANGLEContextANGLE",
+     P(gl::SamplerParameterfvRobustANGLEContextANGLE)},
+    {"glSamplerParameteri", P(gl::SamplerParameteri)},
+    {"glSamplerParameteriContextANGLE", P(gl::SamplerParameteriContextANGLE)},
+    {"glSamplerParameteriv", P(gl::SamplerParameteriv)},
+    {"glSamplerParameterivContextANGLE", P(gl::SamplerParameterivContextANGLE)},
+    {"glSamplerParameterivRobustANGLE", P(gl::SamplerParameterivRobustANGLE)},
+    {"glSamplerParameterivRobustANGLEContextANGLE",
+     P(gl::SamplerParameterivRobustANGLEContextANGLE)},
+    {"glScalef", P(gl::Scalef)},
+    {"glScalefContextANGLE", P(gl::ScalefContextANGLE)},
+    {"glScalex", P(gl::Scalex)},
+    {"glScalexContextANGLE", P(gl::ScalexContextANGLE)},
+    {"glScissor", P(gl::Scissor)},
+    {"glScissorContextANGLE", P(gl::ScissorContextANGLE)},
+    {"glSemaphoreParameterui64vEXT", P(gl::SemaphoreParameterui64vEXT)},
+    {"glSemaphoreParameterui64vEXTContextANGLE", P(gl::SemaphoreParameterui64vEXTContextANGLE)},
+    {"glSetFenceNV", P(gl::SetFenceNV)},
+    {"glSetFenceNVContextANGLE", P(gl::SetFenceNVContextANGLE)},
+    {"glShadeModel", P(gl::ShadeModel)},
+    {"glShadeModelContextANGLE", P(gl::ShadeModelContextANGLE)},
+    {"glShaderBinary", P(gl::ShaderBinary)},
+    {"glShaderBinaryContextANGLE", P(gl::ShaderBinaryContextANGLE)},
+    {"glShaderSource", P(gl::ShaderSource)},
+    {"glShaderSourceContextANGLE", P(gl::ShaderSourceContextANGLE)},
+    {"glSignalSemaphoreEXT", P(gl::SignalSemaphoreEXT)},
+    {"glSignalSemaphoreEXTContextANGLE", P(gl::SignalSemaphoreEXTContextANGLE)},
+    {"glStencilFillPathCHROMIUM", P(gl::StencilFillPathCHROMIUM)},
+    {"glStencilFillPathCHROMIUMContextANGLE", P(gl::StencilFillPathCHROMIUMContextANGLE)},
+    {"glStencilFillPathInstancedCHROMIUM", P(gl::StencilFillPathInstancedCHROMIUM)},
+    {"glStencilFillPathInstancedCHROMIUMContextANGLE",
+     P(gl::StencilFillPathInstancedCHROMIUMContextANGLE)},
+    {"glStencilFunc", P(gl::StencilFunc)},
+    {"glStencilFuncContextANGLE", P(gl::StencilFuncContextANGLE)},
+    {"glStencilFuncSeparate", P(gl::StencilFuncSeparate)},
+    {"glStencilFuncSeparateContextANGLE", P(gl::StencilFuncSeparateContextANGLE)},
+    {"glStencilMask", P(gl::StencilMask)},
+    {"glStencilMaskContextANGLE", P(gl::StencilMaskContextANGLE)},
+    {"glStencilMaskSeparate", P(gl::StencilMaskSeparate)},
+    {"glStencilMaskSeparateContextANGLE", P(gl::StencilMaskSeparateContextANGLE)},
+    {"glStencilOp", P(gl::StencilOp)},
+    {"glStencilOpContextANGLE", P(gl::StencilOpContextANGLE)},
+    {"glStencilOpSeparate", P(gl::StencilOpSeparate)},
+    {"glStencilOpSeparateContextANGLE", P(gl::StencilOpSeparateContextANGLE)},
+    {"glStencilStrokePathCHROMIUM", P(gl::StencilStrokePathCHROMIUM)},
+    {"glStencilStrokePathCHROMIUMContextANGLE", P(gl::StencilStrokePathCHROMIUMContextANGLE)},
+    {"glStencilStrokePathInstancedCHROMIUM", P(gl::StencilStrokePathInstancedCHROMIUM)},
+    {"glStencilStrokePathInstancedCHROMIUMContextANGLE",
+     P(gl::StencilStrokePathInstancedCHROMIUMContextANGLE)},
+    {"glStencilThenCoverFillPathCHROMIUM", P(gl::StencilThenCoverFillPathCHROMIUM)},
+    {"glStencilThenCoverFillPathCHROMIUMContextANGLE",
+     P(gl::StencilThenCoverFillPathCHROMIUMContextANGLE)},
+    {"glStencilThenCoverFillPathInstancedCHROMIUM",
+     P(gl::StencilThenCoverFillPathInstancedCHROMIUM)},
+    {"glStencilThenCoverFillPathInstancedCHROMIUMContextANGLE",
+     P(gl::StencilThenCoverFillPathInstancedCHROMIUMContextANGLE)},
+    {"glStencilThenCoverStrokePathCHROMIUM", P(gl::StencilThenCoverStrokePathCHROMIUM)},
+    {"glStencilThenCoverStrokePathCHROMIUMContextANGLE",
+     P(gl::StencilThenCoverStrokePathCHROMIUMContextANGLE)},
+    {"glStencilThenCoverStrokePathInstancedCHROMIUM",
+     P(gl::StencilThenCoverStrokePathInstancedCHROMIUM)},
+    {"glStencilThenCoverStrokePathInstancedCHROMIUMContextANGLE",
+     P(gl::StencilThenCoverStrokePathInstancedCHROMIUMContextANGLE)},
+    {"glTestFenceNV", P(gl::TestFenceNV)},
+    {"glTestFenceNVContextANGLE", P(gl::TestFenceNVContextANGLE)},
+    {"glTexCoordPointer", P(gl::TexCoordPointer)},
+    {"glTexCoordPointerContextANGLE", P(gl::TexCoordPointerContextANGLE)},
+    {"glTexEnvf", P(gl::TexEnvf)},
+    {"glTexEnvfContextANGLE", P(gl::TexEnvfContextANGLE)},
+    {"glTexEnvfv", P(gl::TexEnvfv)},
+    {"glTexEnvfvContextANGLE", P(gl::TexEnvfvContextANGLE)},
+    {"glTexEnvi", P(gl::TexEnvi)},
+    {"glTexEnviContextANGLE", P(gl::TexEnviContextANGLE)},
+    {"glTexEnviv", P(gl::TexEnviv)},
+    {"glTexEnvivContextANGLE", P(gl::TexEnvivContextANGLE)},
+    {"glTexEnvx", P(gl::TexEnvx)},
+    {"glTexEnvxContextANGLE", P(gl::TexEnvxContextANGLE)},
+    {"glTexEnvxv", P(gl::TexEnvxv)},
+    {"glTexEnvxvContextANGLE", P(gl::TexEnvxvContextANGLE)},
+    {"glTexGenfOES", P(gl::TexGenfOES)},
+    {"glTexGenfOESContextANGLE", P(gl::TexGenfOESContextANGLE)},
+    {"glTexGenfvOES", P(gl::TexGenfvOES)},
+    {"glTexGenfvOESContextANGLE", P(gl::TexGenfvOESContextANGLE)},
+    {"glTexGeniOES", P(gl::TexGeniOES)},
+    {"glTexGeniOESContextANGLE", P(gl::TexGeniOESContextANGLE)},
+    {"glTexGenivOES", P(gl::TexGenivOES)},
+    {"glTexGenivOESContextANGLE", P(gl::TexGenivOESContextANGLE)},
+    {"glTexGenxOES", P(gl::TexGenxOES)},
+    {"glTexGenxOESContextANGLE", P(gl::TexGenxOESContextANGLE)},
+    {"glTexGenxvOES", P(gl::TexGenxvOES)},
+    {"glTexGenxvOESContextANGLE", P(gl::TexGenxvOESContextANGLE)},
+    {"glTexImage2D", P(gl::TexImage2D)},
+    {"glTexImage2DContextANGLE", P(gl::TexImage2DContextANGLE)},
+    {"glTexImage2DExternalANGLE", P(gl::TexImage2DExternalANGLE)},
+    {"glTexImage2DExternalANGLEContextANGLE", P(gl::TexImage2DExternalANGLEContextANGLE)},
+    {"glTexImage2DRobustANGLE", P(gl::TexImage2DRobustANGLE)},
+    {"glTexImage2DRobustANGLEContextANGLE", P(gl::TexImage2DRobustANGLEContextANGLE)},
+    {"glTexImage3D", P(gl::TexImage3D)},
+    {"glTexImage3DContextANGLE", P(gl::TexImage3DContextANGLE)},
+    {"glTexImage3DOES", P(gl::TexImage3DOES)},
+    {"glTexImage3DOESContextANGLE", P(gl::TexImage3DOESContextANGLE)},
+    {"glTexImage3DRobustANGLE", P(gl::TexImage3DRobustANGLE)},
+    {"glTexImage3DRobustANGLEContextANGLE", P(gl::TexImage3DRobustANGLEContextANGLE)},
+    {"glTexParameterIivOES", P(gl::TexParameterIivOES)},
+    {"glTexParameterIivOESContextANGLE", P(gl::TexParameterIivOESContextANGLE)},
+    {"glTexParameterIivRobustANGLE", P(gl::TexParameterIivRobustANGLE)},
+    {"glTexParameterIivRobustANGLEContextANGLE", P(gl::TexParameterIivRobustANGLEContextANGLE)},
+    {"glTexParameterIuivOES", P(gl::TexParameterIuivOES)},
+    {"glTexParameterIuivOESContextANGLE", P(gl::TexParameterIuivOESContextANGLE)},
+    {"glTexParameterIuivRobustANGLE", P(gl::TexParameterIuivRobustANGLE)},
+    {"glTexParameterIuivRobustANGLEContextANGLE", P(gl::TexParameterIuivRobustANGLEContextANGLE)},
+    {"glTexParameterf", P(gl::TexParameterf)},
+    {"glTexParameterfContextANGLE", P(gl::TexParameterfContextANGLE)},
+    {"glTexParameterfv", P(gl::TexParameterfv)},
+    {"glTexParameterfvContextANGLE", P(gl::TexParameterfvContextANGLE)},
+    {"glTexParameterfvRobustANGLE", P(gl::TexParameterfvRobustANGLE)},
+    {"glTexParameterfvRobustANGLEContextANGLE", P(gl::TexParameterfvRobustANGLEContextANGLE)},
+    {"glTexParameteri", P(gl::TexParameteri)},
+    {"glTexParameteriContextANGLE", P(gl::TexParameteriContextANGLE)},
+    {"glTexParameteriv", P(gl::TexParameteriv)},
+    {"glTexParameterivContextANGLE", P(gl::TexParameterivContextANGLE)},
+    {"glTexParameterivRobustANGLE", P(gl::TexParameterivRobustANGLE)},
+    {"glTexParameterivRobustANGLEContextANGLE", P(gl::TexParameterivRobustANGLEContextANGLE)},
+    {"glTexParameterx", P(gl::TexParameterx)},
+    {"glTexParameterxContextANGLE", P(gl::TexParameterxContextANGLE)},
+    {"glTexParameterxv", P(gl::TexParameterxv)},
+    {"glTexParameterxvContextANGLE", P(gl::TexParameterxvContextANGLE)},
+    {"glTexStorage1DEXT", P(gl::TexStorage1DEXT)},
+    {"glTexStorage1DEXTContextANGLE", P(gl::TexStorage1DEXTContextANGLE)},
+    {"glTexStorage2D", P(gl::TexStorage2D)},
+    {"glTexStorage2DContextANGLE", P(gl::TexStorage2DContextANGLE)},
+    {"glTexStorage2DEXT", P(gl::TexStorage2DEXT)},
+    {"glTexStorage2DEXTContextANGLE", P(gl::TexStorage2DEXTContextANGLE)},
+    {"glTexStorage2DMultisample", P(gl::TexStorage2DMultisample)},
+    {"glTexStorage2DMultisampleANGLE", P(gl::TexStorage2DMultisampleANGLE)},
+    {"glTexStorage2DMultisampleANGLEContextANGLE", P(gl::TexStorage2DMultisampleANGLEContextANGLE)},
+    {"glTexStorage2DMultisampleContextANGLE", P(gl::TexStorage2DMultisampleContextANGLE)},
+    {"glTexStorage3D", P(gl::TexStorage3D)},
+    {"glTexStorage3DContextANGLE", P(gl::TexStorage3DContextANGLE)},
+    {"glTexStorage3DEXT", P(gl::TexStorage3DEXT)},
+    {"glTexStorage3DEXTContextANGLE", P(gl::TexStorage3DEXTContextANGLE)},
+    {"glTexStorage3DMultisampleOES", P(gl::TexStorage3DMultisampleOES)},
+    {"glTexStorage3DMultisampleOESContextANGLE", P(gl::TexStorage3DMultisampleOESContextANGLE)},
+    {"glTexStorageMem2DEXT", P(gl::TexStorageMem2DEXT)},
+    {"glTexStorageMem2DEXTContextANGLE", P(gl::TexStorageMem2DEXTContextANGLE)},
+    {"glTexStorageMem2DMultisampleEXT", P(gl::TexStorageMem2DMultisampleEXT)},
+    {"glTexStorageMem2DMultisampleEXTContextANGLE",
+     P(gl::TexStorageMem2DMultisampleEXTContextANGLE)},
+    {"glTexStorageMem3DEXT", P(gl::TexStorageMem3DEXT)},
+    {"glTexStorageMem3DEXTContextANGLE", P(gl::TexStorageMem3DEXTContextANGLE)},
+    {"glTexStorageMem3DMultisampleEXT", P(gl::TexStorageMem3DMultisampleEXT)},
+    {"glTexStorageMem3DMultisampleEXTContextANGLE",
+     P(gl::TexStorageMem3DMultisampleEXTContextANGLE)},
+    {"glTexSubImage2D", P(gl::TexSubImage2D)},
+    {"glTexSubImage2DContextANGLE", P(gl::TexSubImage2DContextANGLE)},
+    {"glTexSubImage2DRobustANGLE", P(gl::TexSubImage2DRobustANGLE)},
+    {"glTexSubImage2DRobustANGLEContextANGLE", P(gl::TexSubImage2DRobustANGLEContextANGLE)},
+    {"glTexSubImage3D", P(gl::TexSubImage3D)},
+    {"glTexSubImage3DContextANGLE", P(gl::TexSubImage3DContextANGLE)},
+    {"glTexSubImage3DOES", P(gl::TexSubImage3DOES)},
+    {"glTexSubImage3DOESContextANGLE", P(gl::TexSubImage3DOESContextANGLE)},
+    {"glTexSubImage3DRobustANGLE", P(gl::TexSubImage3DRobustANGLE)},
+    {"glTexSubImage3DRobustANGLEContextANGLE", P(gl::TexSubImage3DRobustANGLEContextANGLE)},
+    {"glTransformFeedbackVaryings", P(gl::TransformFeedbackVaryings)},
+    {"glTransformFeedbackVaryingsContextANGLE", P(gl::TransformFeedbackVaryingsContextANGLE)},
+    {"glTranslatef", P(gl::Translatef)},
+    {"glTranslatefContextANGLE", P(gl::TranslatefContextANGLE)},
+    {"glTranslatex", P(gl::Translatex)},
+    {"glTranslatexContextANGLE", P(gl::TranslatexContextANGLE)},
+    {"glUniform1f", P(gl::Uniform1f)},
+    {"glUniform1fContextANGLE", P(gl::Uniform1fContextANGLE)},
+    {"glUniform1fv", P(gl::Uniform1fv)},
+    {"glUniform1fvContextANGLE", P(gl::Uniform1fvContextANGLE)},
+    {"glUniform1i", P(gl::Uniform1i)},
+    {"glUniform1iContextANGLE", P(gl::Uniform1iContextANGLE)},
+    {"glUniform1iv", P(gl::Uniform1iv)},
+    {"glUniform1ivContextANGLE", P(gl::Uniform1ivContextANGLE)},
+    {"glUniform1ui", P(gl::Uniform1ui)},
+    {"glUniform1uiContextANGLE", P(gl::Uniform1uiContextANGLE)},
+    {"glUniform1uiv", P(gl::Uniform1uiv)},
+    {"glUniform1uivContextANGLE", P(gl::Uniform1uivContextANGLE)},
+    {"glUniform2f", P(gl::Uniform2f)},
+    {"glUniform2fContextANGLE", P(gl::Uniform2fContextANGLE)},
+    {"glUniform2fv", P(gl::Uniform2fv)},
+    {"glUniform2fvContextANGLE", P(gl::Uniform2fvContextANGLE)},
+    {"glUniform2i", P(gl::Uniform2i)},
+    {"glUniform2iContextANGLE", P(gl::Uniform2iContextANGLE)},
+    {"glUniform2iv", P(gl::Uniform2iv)},
+    {"glUniform2ivContextANGLE", P(gl::Uniform2ivContextANGLE)},
+    {"glUniform2ui", P(gl::Uniform2ui)},
+    {"glUniform2uiContextANGLE", P(gl::Uniform2uiContextANGLE)},
+    {"glUniform2uiv", P(gl::Uniform2uiv)},
+    {"glUniform2uivContextANGLE", P(gl::Uniform2uivContextANGLE)},
+    {"glUniform3f", P(gl::Uniform3f)},
+    {"glUniform3fContextANGLE", P(gl::Uniform3fContextANGLE)},
+    {"glUniform3fv", P(gl::Uniform3fv)},
+    {"glUniform3fvContextANGLE", P(gl::Uniform3fvContextANGLE)},
+    {"glUniform3i", P(gl::Uniform3i)},
+    {"glUniform3iContextANGLE", P(gl::Uniform3iContextANGLE)},
+    {"glUniform3iv", P(gl::Uniform3iv)},
+    {"glUniform3ivContextANGLE", P(gl::Uniform3ivContextANGLE)},
+    {"glUniform3ui", P(gl::Uniform3ui)},
+    {"glUniform3uiContextANGLE", P(gl::Uniform3uiContextANGLE)},
+    {"glUniform3uiv", P(gl::Uniform3uiv)},
+    {"glUniform3uivContextANGLE", P(gl::Uniform3uivContextANGLE)},
+    {"glUniform4f", P(gl::Uniform4f)},
+    {"glUniform4fContextANGLE", P(gl::Uniform4fContextANGLE)},
+    {"glUniform4fv", P(gl::Uniform4fv)},
+    {"glUniform4fvContextANGLE", P(gl::Uniform4fvContextANGLE)},
+    {"glUniform4i", P(gl::Uniform4i)},
+    {"glUniform4iContextANGLE", P(gl::Uniform4iContextANGLE)},
+    {"glUniform4iv", P(gl::Uniform4iv)},
+    {"glUniform4ivContextANGLE", P(gl::Uniform4ivContextANGLE)},
+    {"glUniform4ui", P(gl::Uniform4ui)},
+    {"glUniform4uiContextANGLE", P(gl::Uniform4uiContextANGLE)},
+    {"glUniform4uiv", P(gl::Uniform4uiv)},
+    {"glUniform4uivContextANGLE", P(gl::Uniform4uivContextANGLE)},
+    {"glUniformBlockBinding", P(gl::UniformBlockBinding)},
+    {"glUniformBlockBindingContextANGLE", P(gl::UniformBlockBindingContextANGLE)},
+    {"glUniformMatrix2fv", P(gl::UniformMatrix2fv)},
+    {"glUniformMatrix2fvContextANGLE", P(gl::UniformMatrix2fvContextANGLE)},
+    {"glUniformMatrix2x3fv", P(gl::UniformMatrix2x3fv)},
+    {"glUniformMatrix2x3fvContextANGLE", P(gl::UniformMatrix2x3fvContextANGLE)},
+    {"glUniformMatrix2x4fv", P(gl::UniformMatrix2x4fv)},
+    {"glUniformMatrix2x4fvContextANGLE", P(gl::UniformMatrix2x4fvContextANGLE)},
+    {"glUniformMatrix3fv", P(gl::UniformMatrix3fv)},
+    {"glUniformMatrix3fvContextANGLE", P(gl::UniformMatrix3fvContextANGLE)},
+    {"glUniformMatrix3x2fv", P(gl::UniformMatrix3x2fv)},
+    {"glUniformMatrix3x2fvContextANGLE", P(gl::UniformMatrix3x2fvContextANGLE)},
+    {"glUniformMatrix3x4fv", P(gl::UniformMatrix3x4fv)},
+    {"glUniformMatrix3x4fvContextANGLE", P(gl::UniformMatrix3x4fvContextANGLE)},
+    {"glUniformMatrix4fv", P(gl::UniformMatrix4fv)},
+    {"glUniformMatrix4fvContextANGLE", P(gl::UniformMatrix4fvContextANGLE)},
+    {"glUniformMatrix4x2fv", P(gl::UniformMatrix4x2fv)},
+    {"glUniformMatrix4x2fvContextANGLE", P(gl::UniformMatrix4x2fvContextANGLE)},
+    {"glUniformMatrix4x3fv", P(gl::UniformMatrix4x3fv)},
+    {"glUniformMatrix4x3fvContextANGLE", P(gl::UniformMatrix4x3fvContextANGLE)},
+    {"glUnmapBuffer", P(gl::UnmapBuffer)},
+    {"glUnmapBufferContextANGLE", P(gl::UnmapBufferContextANGLE)},
+    {"glUnmapBufferOES", P(gl::UnmapBufferOES)},
+    {"glUnmapBufferOESContextANGLE", P(gl::UnmapBufferOESContextANGLE)},
+    {"glUseProgram", P(gl::UseProgram)},
+    {"glUseProgramContextANGLE", P(gl::UseProgramContextANGLE)},
+    {"glUseProgramStages", P(gl::UseProgramStages)},
+    {"glUseProgramStagesContextANGLE", P(gl::UseProgramStagesContextANGLE)},
+    {"glValidateProgram", P(gl::ValidateProgram)},
+    {"glValidateProgramContextANGLE", P(gl::ValidateProgramContextANGLE)},
+    {"glValidateProgramPipeline", P(gl::ValidateProgramPipeline)},
+    {"glValidateProgramPipelineContextANGLE", P(gl::ValidateProgramPipelineContextANGLE)},
+    {"glVertexAttrib1f", P(gl::VertexAttrib1f)},
+    {"glVertexAttrib1fContextANGLE", P(gl::VertexAttrib1fContextANGLE)},
+    {"glVertexAttrib1fv", P(gl::VertexAttrib1fv)},
+    {"glVertexAttrib1fvContextANGLE", P(gl::VertexAttrib1fvContextANGLE)},
+    {"glVertexAttrib2f", P(gl::VertexAttrib2f)},
+    {"glVertexAttrib2fContextANGLE", P(gl::VertexAttrib2fContextANGLE)},
+    {"glVertexAttrib2fv", P(gl::VertexAttrib2fv)},
+    {"glVertexAttrib2fvContextANGLE", P(gl::VertexAttrib2fvContextANGLE)},
+    {"glVertexAttrib3f", P(gl::VertexAttrib3f)},
+    {"glVertexAttrib3fContextANGLE", P(gl::VertexAttrib3fContextANGLE)},
+    {"glVertexAttrib3fv", P(gl::VertexAttrib3fv)},
+    {"glVertexAttrib3fvContextANGLE", P(gl::VertexAttrib3fvContextANGLE)},
+    {"glVertexAttrib4f", P(gl::VertexAttrib4f)},
+    {"glVertexAttrib4fContextANGLE", P(gl::VertexAttrib4fContextANGLE)},
+    {"glVertexAttrib4fv", P(gl::VertexAttrib4fv)},
+    {"glVertexAttrib4fvContextANGLE", P(gl::VertexAttrib4fvContextANGLE)},
+    {"glVertexAttribBinding", P(gl::VertexAttribBinding)},
+    {"glVertexAttribBindingContextANGLE", P(gl::VertexAttribBindingContextANGLE)},
+    {"glVertexAttribDivisor", P(gl::VertexAttribDivisor)},
+    {"glVertexAttribDivisorANGLE", P(gl::VertexAttribDivisorANGLE)},
+    {"glVertexAttribDivisorANGLEContextANGLE", P(gl::VertexAttribDivisorANGLEContextANGLE)},
+    {"glVertexAttribDivisorContextANGLE", P(gl::VertexAttribDivisorContextANGLE)},
+    {"glVertexAttribDivisorEXT", P(gl::VertexAttribDivisorEXT)},
+    {"glVertexAttribDivisorEXTContextANGLE", P(gl::VertexAttribDivisorEXTContextANGLE)},
+    {"glVertexAttribFormat", P(gl::VertexAttribFormat)},
+    {"glVertexAttribFormatContextANGLE", P(gl::VertexAttribFormatContextANGLE)},
+    {"glVertexAttribI4i", P(gl::VertexAttribI4i)},
+    {"glVertexAttribI4iContextANGLE", P(gl::VertexAttribI4iContextANGLE)},
+    {"glVertexAttribI4iv", P(gl::VertexAttribI4iv)},
+    {"glVertexAttribI4ivContextANGLE", P(gl::VertexAttribI4ivContextANGLE)},
+    {"glVertexAttribI4ui", P(gl::VertexAttribI4ui)},
+    {"glVertexAttribI4uiContextANGLE", P(gl::VertexAttribI4uiContextANGLE)},
+    {"glVertexAttribI4uiv", P(gl::VertexAttribI4uiv)},
+    {"glVertexAttribI4uivContextANGLE", P(gl::VertexAttribI4uivContextANGLE)},
+    {"glVertexAttribIFormat", P(gl::VertexAttribIFormat)},
+    {"glVertexAttribIFormatContextANGLE", P(gl::VertexAttribIFormatContextANGLE)},
+    {"glVertexAttribIPointer", P(gl::VertexAttribIPointer)},
+    {"glVertexAttribIPointerContextANGLE", P(gl::VertexAttribIPointerContextANGLE)},
+    {"glVertexAttribPointer", P(gl::VertexAttribPointer)},
+    {"glVertexAttribPointerContextANGLE", P(gl::VertexAttribPointerContextANGLE)},
+    {"glVertexBindingDivisor", P(gl::VertexBindingDivisor)},
+    {"glVertexBindingDivisorContextANGLE", P(gl::VertexBindingDivisorContextANGLE)},
+    {"glVertexPointer", P(gl::VertexPointer)},
+    {"glVertexPointerContextANGLE", P(gl::VertexPointerContextANGLE)},
+    {"glViewport", P(gl::Viewport)},
+    {"glViewportContextANGLE", P(gl::ViewportContextANGLE)},
+    {"glWaitSemaphoreEXT", P(gl::WaitSemaphoreEXT)},
+    {"glWaitSemaphoreEXTContextANGLE", P(gl::WaitSemaphoreEXTContextANGLE)},
+    {"glWaitSync", P(gl::WaitSync)},
+    {"glWaitSyncContextANGLE", P(gl::WaitSyncContextANGLE)},
+    {"glWeightPointerOES", P(gl::WeightPointerOES)},
+    {"glWeightPointerOESContextANGLE", P(gl::WeightPointerOESContextANGLE)}};
+
+size_t g_numProcs = 1402;
+}  // namespace egl
diff --git a/gfx/angle/checkout/src/libGLESv2/resource.h b/gfx/angle/checkout/src/libGLESv2/resource.h
new file mode 100644
index 0000000000..7308c2ecfd
--- /dev/null
+++ b/gfx/angle/checkout/src/libGLESv2/resource.h
@@ -0,0 +1,14 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by libGLESv2.rc
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#    ifndef APSTUDIO_READONLY_SYMBOLS
+#        define _APS_NEXT_RESOURCE_VALUE 101
+#        define _APS_NEXT_COMMAND_VALUE 40001
+#        define _APS_NEXT_CONTROL_VALUE 1001
+#        define _APS_NEXT_SYMED_VALUE 101
+#    endif
+#endif