projects / mesa.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
egl: replace `&_eglDriver`/`NULL` tested against `NULL` with simple `true`/`false`
[mesa.git] / src / egl / main / eglapi.c
diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c
index 39e1ca2c7e05473a8848595095f3e5bcb5a1abd0..9c78e9c343e7e78fd3d7be667d9c751d171bc1c8 100644 (file)
--- a/src/egl/main/eglapi.c
+++ b/src/egl/main/eglapi.c
@@ -138,31 +138,29 @@
  * A bunch of macros and checks to simplify error checking.
  */
 
-#define _EGL_CHECK_DISPLAY(disp, ret, drv)         \
+#define _EGL_CHECK_DISPLAY(disp, ret)              \
    do {                                            \
-      drv = _eglCheckDisplay(disp, __func__);      \
-      if (!drv)                                    \
+      if (!_eglCheckDisplay(disp, __func__))       \
          RETURN_EGL_ERROR(disp, 0, ret);           \
    } while (0)
 
-#define _EGL_CHECK_OBJECT(disp, type, obj, ret, drv)      \
+#define _EGL_CHECK_OBJECT(disp, type, obj, ret)           \
    do {                                                   \
-      drv = _eglCheck ## type(disp, obj, __func__);       \
-      if (!drv)                                           \
+      if (!_eglCheck ## type(disp, obj, __func__))        \
          RETURN_EGL_ERROR(disp, 0, ret);                  \
    } while (0)
 
-#define _EGL_CHECK_SURFACE(disp, surf, ret, drv) \
-   _EGL_CHECK_OBJECT(disp, Surface, surf, ret, drv)
+#define _EGL_CHECK_SURFACE(disp, surf, ret) \
+   _EGL_CHECK_OBJECT(disp, Surface, surf, ret)
 
-#define _EGL_CHECK_CONTEXT(disp, context, ret, drv) \
-   _EGL_CHECK_OBJECT(disp, Context, context, ret, drv)
+#define _EGL_CHECK_CONTEXT(disp, context, ret) \
+   _EGL_CHECK_OBJECT(disp, Context, context, ret)
 
-#define _EGL_CHECK_CONFIG(disp, conf, ret, drv) \
-   _EGL_CHECK_OBJECT(disp, Config, conf, ret, drv)
+#define _EGL_CHECK_CONFIG(disp, conf, ret) \
+   _EGL_CHECK_OBJECT(disp, Config, conf, ret)
 
-#define _EGL_CHECK_SYNC(disp, s, ret, drv) \
-   _EGL_CHECK_OBJECT(disp, Sync, s, ret, drv)
+#define _EGL_CHECK_SYNC(disp, s, ret) \
+   _EGL_CHECK_OBJECT(disp, Sync, s, ret)
 
 
 struct _egl_entrypoint {
@@ -171,74 +169,70 @@ struct _egl_entrypoint {
 };
 
 
-static inline const _EGLDriver *
+static inline bool
 _eglCheckDisplay(_EGLDisplay *disp, const char *msg)
 {
    if (!disp) {
       _eglError(EGL_BAD_DISPLAY, msg);
-      return NULL;
+      return false;
    }
    if (!disp->Initialized) {
       _eglError(EGL_NOT_INITIALIZED, msg);
-      return NULL;
+      return false;
    }
-   return disp->Driver;
+   return true;
 }
 
 
-static inline const _EGLDriver *
+static inline bool
 _eglCheckSurface(_EGLDisplay *disp, _EGLSurface *surf, const char *msg)
 {
-   const _EGLDriver *drv = _eglCheckDisplay(disp, msg);
-   if (!drv)
-      return NULL;
+   if (!_eglCheckDisplay(disp, msg))
+      return false;
    if (!surf) {
       _eglError(EGL_BAD_SURFACE, msg);
-      return NULL;
+      return false;
    }
-   return drv;
+   return true;
 }
 
 
-static inline const _EGLDriver *
+static inline bool
 _eglCheckContext(_EGLDisplay *disp, _EGLContext *context, const char *msg)
 {
-   const _EGLDriver *drv = _eglCheckDisplay(disp, msg);
-   if (!drv)
-      return NULL;
+   if (!_eglCheckDisplay(disp, msg))
+      return false;
    if (!context) {
       _eglError(EGL_BAD_CONTEXT, msg);
-      return NULL;
+      return false;
    }
-   return drv;
+   return true;
 }
 
 
-static inline const _EGLDriver *
+static inline bool
 _eglCheckConfig(_EGLDisplay *disp, _EGLConfig *conf, const char *msg)
 {
-   const _EGLDriver *drv = _eglCheckDisplay(disp, msg);
-   if (!drv)
-      return NULL;
+   if (!_eglCheckDisplay(disp, msg))
+      return false;
    if (!conf) {
       _eglError(EGL_BAD_CONFIG, msg);
-      return NULL;
+      return false;
    }
-   return drv;
+   return true;
 }
 
 
-static inline const _EGLDriver *
+static inline bool
 _eglCheckSync(_EGLDisplay *disp, _EGLSync *s, const char *msg)
 {
-   const _EGLDriver *drv = _eglCheckDisplay(disp, msg);
-   if (!drv)
-      return NULL;
+   if (!_eglCheckDisplay(disp, msg))
+      return false;
    if (!s) {
       _eglError(EGL_BAD_PARAMETER, msg);
-      return NULL;
+      return false;
    }
-   return drv;
+   return true;
 }
 
 
@@ -690,7 +684,6 @@ const char * EGLAPIENTRY
 eglQueryString(EGLDisplay dpy, EGLint name)
 {
    _EGLDisplay *disp;
-   const _EGLDriver *drv;
 
 #if !USE_LIBGLVND
    if (dpy == EGL_NO_DISPLAY && name == EGL_EXTENSIONS) {
@@ -700,7 +693,7 @@ eglQueryString(EGLDisplay dpy, EGLint name)
 
    disp = _eglLockDisplay(dpy);
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, NULL);
-   _EGL_CHECK_DISPLAY(disp, NULL, drv);
+   _EGL_CHECK_DISPLAY(disp, NULL);
 
    switch (name) {
    case EGL_VENDOR:
@@ -722,17 +715,16 @@ eglGetConfigs(EGLDisplay dpy, EGLConfig *configs,
               EGLint config_size, EGLint *num_config)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
 
    if (!num_config)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = _eglGetConfigs(drv, disp, configs, config_size, num_config);
+   ret = _eglGetConfigs(disp, configs, config_size, num_config);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -743,17 +735,16 @@ eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs,
                 EGLint config_size, EGLint *num_config)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
 
    if (!num_config)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = _eglChooseConfig(drv, disp, attrib_list, configs,
+   ret = _eglChooseConfig(disp, attrib_list, configs,
                           config_size, num_config);
 
    RETURN_EGL_EVAL(disp, ret);
@@ -766,14 +757,13 @@ eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLConfig *conf = _eglLookupConfig(config, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
 
-   _EGL_CHECK_CONFIG(disp, conf, EGL_FALSE, drv);
+   _EGL_CHECK_CONFIG(disp, conf, EGL_FALSE);
 
-   ret = _eglGetConfigAttrib(drv, disp, conf, attribute, value);
+   ret = _eglGetConfigAttrib(disp, conf, attribute, value);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -786,23 +776,22 @@ eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_list,
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLConfig *conf = _eglLookupConfig(config, disp);
    _EGLContext *share = _eglLookupContext(share_list, disp);
-   const _EGLDriver *drv;
    _EGLContext *context;
    EGLContext ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_CONTEXT);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_NO_CONTEXT, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_NO_CONTEXT);
 
    if (config != EGL_NO_CONFIG_KHR)
-      _EGL_CHECK_CONFIG(disp, conf, EGL_NO_CONTEXT, drv);
+      _EGL_CHECK_CONFIG(disp, conf, EGL_NO_CONTEXT);
    else if (!disp->Extensions.KHR_no_config_context)
       RETURN_EGL_ERROR(disp, EGL_BAD_CONFIG, EGL_NO_CONTEXT);
 
    if (!share && share_list != EGL_NO_CONTEXT)
       RETURN_EGL_ERROR(disp, EGL_BAD_CONTEXT, EGL_NO_CONTEXT);
 
-   context = drv->CreateContext(disp, conf, share, attrib_list);
+   context = disp->Driver->CreateContext(disp, conf, share, attrib_list);
    ret = (context) ? _eglLinkContext(context) : EGL_NO_CONTEXT;
 
    RETURN_EGL_EVAL(disp, ret);
@@ -814,14 +803,13 @@ eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLContext *context = _eglLookupContext(ctx, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_CONTEXT_KHR, context, EGL_FALSE);
 
-   _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE, drv);
+   _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE);
    _eglUnlinkContext(context);
-   ret = drv->DestroyContext(disp, context);
+   ret = disp->Driver->DestroyContext(disp, context);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -835,14 +823,12 @@ eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
    _EGLContext *context = _eglLookupContext(ctx, disp);
    _EGLSurface *draw_surf = _eglLookupSurface(draw, disp);
    _EGLSurface *read_surf = _eglLookupSurface(read, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_CONTEXT_KHR, context, EGL_FALSE);
 
    if (!disp)
       RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
-   drv = disp->Driver;
 
    /* display is allowed to be uninitialized under certain condition */
    if (!disp->Initialized) {
@@ -850,7 +836,7 @@ eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
           ctx != EGL_NO_CONTEXT)
          RETURN_EGL_ERROR(disp, EGL_BAD_DISPLAY, EGL_FALSE);
    }
-   if (!drv)
+   if (!disp->Driver)
       RETURN_EGL_SUCCESS(disp, EGL_TRUE);
 
    if (!context && ctx != EGL_NO_CONTEXT)
@@ -879,7 +865,7 @@ eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read,
    if (read_surf && read_surf->Lost)
       RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_FALSE);
 
-   ret = drv->MakeCurrent(disp, draw_surf, read_surf, context);
+   ret = disp->Driver->MakeCurrent(disp, draw_surf, read_surf, context);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -891,14 +877,13 @@ eglQueryContext(EGLDisplay dpy, EGLContext ctx,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLContext *context = _eglLookupContext(ctx, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_CONTEXT_KHR, context, EGL_FALSE);
 
-   _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE, drv);
+   _EGL_CHECK_CONTEXT(disp, context, EGL_FALSE);
 
-   ret = _eglQueryContext(drv, disp, context, attribute, value);
+   ret = _eglQueryContext(context, attribute, value);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -935,7 +920,6 @@ _eglCreateWindowSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
                               void *native_window, const EGLint *attrib_list)
 {
    _EGLConfig *conf = _eglLookupConfig(config, disp);
-   const _EGLDriver *drv;
    _EGLSurface *surf;
    EGLSurface ret;
 
@@ -960,7 +944,7 @@ _eglCreateWindowSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
       RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
    }
 
-   _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
+   _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    if ((conf->SurfaceType & EGL_WINDOW_BIT) == 0)
       RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SURFACE);
@@ -968,7 +952,7 @@ _eglCreateWindowSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
    if (_eglNativeSurfaceAlreadyUsed(disp, native_window))
       RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_SURFACE);
 
-   surf = drv->CreateWindowSurface(disp, conf, native_window, attrib_list);
+   surf = disp->Driver->CreateWindowSurface(disp, conf, native_window, attrib_list);
    ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
 
    RETURN_EGL_EVAL(disp, ret);
@@ -1064,7 +1048,6 @@ _eglCreatePixmapSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
                               void *native_pixmap, const EGLint *attrib_list)
 {
    _EGLConfig *conf = _eglLookupConfig(config, disp);
-   const _EGLDriver *drv;
    _EGLSurface *surf;
    EGLSurface ret;
 
@@ -1083,7 +1066,7 @@ _eglCreatePixmapSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
       RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_PIXMAP, EGL_NO_SURFACE);
    }
 
-   _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
+   _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    if ((conf->SurfaceType & EGL_PIXMAP_BIT) == 0)
       RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SURFACE);
@@ -1094,7 +1077,7 @@ _eglCreatePixmapSurfaceCommon(_EGLDisplay *disp, EGLConfig config,
    if (_eglNativeSurfaceAlreadyUsed(disp, native_pixmap))
       RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_SURFACE);
 
-   surf = drv->CreatePixmapSurface(disp, conf, native_pixmap, attrib_list);
+   surf = disp->Driver->CreatePixmapSurface(disp, conf, native_pixmap, attrib_list);
    ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
 
    RETURN_EGL_EVAL(disp, ret);
@@ -1156,17 +1139,16 @@ eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLConfig *conf = _eglLookupConfig(config, disp);
-   const _EGLDriver *drv;
    _EGLSurface *surf;
    EGLSurface ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
-   _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
+   _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    if ((conf->SurfaceType & EGL_PBUFFER_BIT) == 0)
       RETURN_EGL_ERROR(disp, EGL_BAD_MATCH, EGL_NO_SURFACE);
 
-   surf = drv->CreatePbufferSurface(disp, conf, attrib_list);
+   surf = disp->Driver->CreatePbufferSurface(disp, conf, attrib_list);
    ret = (surf) ? _eglLinkSurface(surf) : EGL_NO_SURFACE;
 
    RETURN_EGL_EVAL(disp, ret);
@@ -1178,13 +1160,12 @@ eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
    _eglUnlinkSurface(surf);
-   ret = drv->DestroySurface(disp, surf);
+   ret = disp->Driver->DestroySurface(disp, surf);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -1195,14 +1176,13 @@ eglQuerySurface(EGLDisplay dpy, EGLSurface surface,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
 
-   if (drv->QuerySurface)
-      ret = drv->QuerySurface(disp, surf, attribute, value);
+   if (disp->Driver->QuerySurface)
+      ret = disp->Driver->QuerySurface(disp, surf, attribute, value);
    else
       ret = _eglQuerySurface(disp, surf, attribute, value);
 
@@ -1215,13 +1195,12 @@ eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
 
-   ret = _eglSurfaceAttrib(drv, disp, surf, attribute, value);
+   ret = _eglSurfaceAttrib(disp, surf, attribute, value);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -1232,12 +1211,11 @@ eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
-   ret = drv->BindTexImage(disp, surf, buffer);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
+   ret = disp->Driver->BindTexImage(disp, surf, buffer);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -1248,12 +1226,11 @@ eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
-   ret = drv->ReleaseTexImage(disp, surf, buffer);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
+   ret = disp->Driver->ReleaseTexImage(disp, surf, buffer);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -1265,11 +1242,10 @@ eglSwapInterval(EGLDisplay dpy, EGLint interval)
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLContext *ctx = _eglGetCurrentContext();
    _EGLSurface *surf = ctx ? ctx->DrawSurface : NULL;
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
 
    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
        ctx->Resource.Display != disp)
@@ -1286,8 +1262,8 @@ eglSwapInterval(EGLDisplay dpy, EGLint interval)
                     surf->Config->MaxSwapInterval);
 
    if (surf->SwapInterval != interval) {
-      if (drv->SwapInterval)
-         ret = drv->SwapInterval(disp, surf, interval);
+      if (disp->Driver->SwapInterval)
+         ret = disp->Driver->SwapInterval(disp, surf, interval);
       else
          ret = _eglSwapInterval(disp, surf, interval);
    }
@@ -1308,11 +1284,10 @@ eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
    _EGLContext *ctx = _eglGetCurrentContext();
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
 
    /* surface must be bound to current context in EGL 1.4 */
    #ifndef _EGL_BUILT_IN_DRIVER_HAIKU
@@ -1333,7 +1308,7 @@ eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
    if (surf->Lost)
       RETURN_EGL_ERROR(disp, EGL_BAD_NATIVE_WINDOW, EGL_FALSE);
 
-   ret = drv->SwapBuffers(disp, surf);
+   ret = disp->Driver->SwapBuffers(disp, surf);
 
    /* EGL_KHR_partial_update
     * Frame boundary successfully reached,
@@ -1353,10 +1328,9 @@ _eglSwapBuffersWithDamageCommon(_EGLDisplay *disp, _EGLSurface *surf,
                                 const EGLint *rects, EGLint n_rects)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
 
    /* surface must be bound to current context in EGL 1.4 */
    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
@@ -1369,7 +1343,7 @@ _eglSwapBuffersWithDamageCommon(_EGLDisplay *disp, _EGLSurface *surf,
    if ((n_rects > 0 && rects == NULL) || n_rects < 0)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->SwapBuffersWithDamageEXT(disp, surf, rects, n_rects);
+   ret = disp->Driver->SwapBuffersWithDamageEXT(disp, surf, rects, n_rects);
 
    /* EGL_KHR_partial_update
     * Frame boundary successfully reached,
@@ -1408,7 +1382,7 @@ eglSwapBuffersWithDamageKHR(EGLDisplay dpy, EGLSurface surface,
  */
 
 static void
-_eglSetDamageRegionKHRClampRects(_EGLDisplay* disp, _EGLSurface* surf,
+_eglSetDamageRegionKHRClampRects(_EGLSurface* surf,
                                  EGLint *rects, EGLint n_rects)
 {
    EGLint i;
@@ -1437,9 +1411,8 @@ eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface,
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
    _EGLContext *ctx = _eglGetCurrentContext();
-   const _EGLDriver *drv;
    EGLBoolean ret;
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
 
    if (_eglGetContextHandle(ctx) == EGL_NO_CONTEXT ||
        surf->Type != EGL_WINDOW_BIT ||
@@ -1455,8 +1428,8 @@ eglSetDamageRegionKHR(EGLDisplay dpy, EGLSurface surface,
    if (surf->SetDamageRegionCalled || !surf->BufferAgeRead)
       RETURN_EGL_ERROR(disp, EGL_BAD_ACCESS, EGL_FALSE);
 
-   _eglSetDamageRegionKHRClampRects(disp, surf, rects, n_rects);
-   ret = drv->SetDamageRegion(disp, surf, rects, n_rects);
+   _eglSetDamageRegionKHRClampRects(surf, rects, n_rects);
+   ret = disp->Driver->SetDamageRegion(disp, surf, rects, n_rects);
 
    if (ret)
       surf->SetDamageRegionCalled = EGL_TRUE;
@@ -1469,7 +1442,6 @@ eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
    void *native_pixmap_ptr;
 
@@ -1477,8 +1449,8 @@ eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
    STATIC_ASSERT(sizeof(void*) == sizeof(target));
    native_pixmap_ptr = (void*) target;
 
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
-   ret = drv->CopyBuffers(disp, surf, native_pixmap_ptr);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
+   ret = disp->Driver->CopyBuffers(disp, surf, native_pixmap_ptr);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -1678,11 +1650,10 @@ eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLConfig *conf = _eglLookupConfig(config, disp);
-   const _EGLDriver *drv;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_NO_SURFACE);
 
-   _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE, drv);
+   _EGL_CHECK_CONFIG(disp, conf, EGL_NO_SURFACE);
 
    /* OpenVG is not supported */
    RETURN_EGL_ERROR(disp, EGL_BAD_ALLOC, EGL_NO_SURFACE);
@@ -1719,11 +1690,10 @@ _eglCreateImageCommon(_EGLDisplay *disp, EGLContext ctx, EGLenum target,
                       EGLClientBuffer buffer, const EGLint *attr_list)
 {
    _EGLContext *context = _eglLookupContext(ctx, disp);
-   const _EGLDriver *drv;
    _EGLImage *img;
    EGLImage ret;
 
-   _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR);
    if (!disp->Extensions.KHR_image_base)
       RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
    if (!context && ctx != EGL_NO_CONTEXT)
@@ -1734,7 +1704,7 @@ _eglCreateImageCommon(_EGLDisplay *disp, EGLContext ctx, EGLenum target,
    if (ctx != EGL_NO_CONTEXT && target == EGL_LINUX_DMA_BUF_EXT)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
 
-   img = drv->CreateImageKHR(disp, context, target, buffer, attr_list);
+   img = disp->Driver->CreateImageKHR(disp, context, target, buffer, attr_list);
    ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
 
    RETURN_EGL_EVAL(disp, ret);
@@ -1773,17 +1743,16 @@ eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target,
 static EGLBoolean
 _eglDestroyImageCommon(_EGLDisplay *disp, _EGLImage *img)
 {
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
    if (!disp->Extensions.KHR_image_base)
       RETURN_EGL_EVAL(disp, EGL_FALSE);
    if (!img)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
    _eglUnlinkImage(img);
-   ret = drv->DestroyImageKHR(disp, img);
+   ret = disp->Driver->DestroyImageKHR(disp, img);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -1813,11 +1782,10 @@ _eglCreateSync(_EGLDisplay *disp, EGLenum type, const EGLAttrib *attrib_list,
                EGLenum invalid_type_error)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
-   const _EGLDriver *drv;
    _EGLSync *sync;
    EGLSync ret;
 
-   _EGL_CHECK_DISPLAY(disp, EGL_NO_SYNC_KHR, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_NO_SYNC_KHR);
 
    if (!disp->Extensions.KHR_cl_event2 && orig_is_EGLAttrib) {
       /* There exist two EGLAttrib variants of eglCreateSync*:
@@ -1867,7 +1835,7 @@ _eglCreateSync(_EGLDisplay *disp, EGLenum type, const EGLAttrib *attrib_list,
       RETURN_EGL_ERROR(disp, invalid_type_error, EGL_NO_SYNC_KHR);
    }
 
-   sync = drv->CreateSyncKHR(disp, type, attrib_list);
+   sync = disp->Driver->CreateSyncKHR(disp, type, attrib_list);
    ret = (sync) ? _eglLinkSync(sync) : EGL_NO_SYNC_KHR;
 
    RETURN_EGL_EVAL(disp, ret);
@@ -1926,16 +1894,15 @@ eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
 static EGLBoolean
 _eglDestroySync(_EGLDisplay *disp, _EGLSync *s)
 {
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
-   _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
+   _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
    assert(disp->Extensions.KHR_reusable_sync ||
           disp->Extensions.KHR_fence_sync ||
           disp->Extensions.ANDROID_native_fence_sync);
 
    _eglUnlinkSync(s);
-   ret = drv->DestroySyncKHR(disp, s);
+   ret = disp->Driver->DestroySyncKHR(disp, s);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -1963,10 +1930,9 @@ static EGLint
 _eglClientWaitSyncCommon(_EGLDisplay *disp, EGLDisplay dpy,
                          _EGLSync *s, EGLint flags, EGLTime timeout)
 {
-   const _EGLDriver *drv;
    EGLint ret;
 
-   _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
+   _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
    assert(disp->Extensions.KHR_reusable_sync ||
           disp->Extensions.KHR_fence_sync ||
           disp->Extensions.ANDROID_native_fence_sync);
@@ -1982,7 +1948,7 @@ _eglClientWaitSyncCommon(_EGLDisplay *disp, EGLDisplay dpy,
    if (s->Type == EGL_SYNC_REUSABLE_KHR)
       _eglUnlockDisplay(dpy);
 
-   ret = drv->ClientWaitSyncKHR(disp, s, flags, timeout);
+   ret = disp->Driver->ClientWaitSyncKHR(disp, s, flags, timeout);
 
    /*
     * 'disp' is already unlocked for reusable sync type,
@@ -2019,10 +1985,9 @@ static EGLint
 _eglWaitSyncCommon(_EGLDisplay *disp, _EGLSync *s, EGLint flags)
 {
    _EGLContext *ctx = _eglGetCurrentContext();
-   const _EGLDriver *drv;
    EGLint ret;
 
-   _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
+   _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
    assert(disp->Extensions.KHR_wait_sync);
 
    /* return an error if the client API doesn't support GL_[OES|MESA]_EGL_sync. */
@@ -2035,7 +2000,7 @@ _eglWaitSyncCommon(_EGLDisplay *disp, _EGLSync *s, EGLint flags)
    if (flags != 0)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->WaitSyncKHR(disp, s);
+   ret = disp->Driver->WaitSyncKHR(disp, s);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2069,14 +2034,13 @@ eglSignalSyncKHR(EGLDisplay dpy, EGLSync sync, EGLenum mode)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSync *s = _eglLookupSync(sync, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
 
-   _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
+   _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
    assert(disp->Extensions.KHR_reusable_sync);
-   ret = drv->SignalSyncKHR(disp, s, mode);
+   ret = disp->Driver->SignalSyncKHR(disp, s, mode);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2085,15 +2049,14 @@ eglSignalSyncKHR(EGLDisplay dpy, EGLSync sync, EGLenum mode)
 static EGLBoolean
 _eglGetSyncAttribCommon(_EGLDisplay *disp, _EGLSync *s, EGLint attribute, EGLAttrib *value)
 {
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
-   _EGL_CHECK_SYNC(disp, s, EGL_FALSE, drv);
+   _EGL_CHECK_SYNC(disp, s, EGL_FALSE);
    assert(disp->Extensions.KHR_reusable_sync ||
           disp->Extensions.KHR_fence_sync ||
           disp->Extensions.ANDROID_native_fence_sync);
 
-   ret = _eglGetSyncAttrib(drv, disp, s, attribute, value);
+   ret = _eglGetSyncAttrib(disp, s, attribute, value);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2144,7 +2107,6 @@ eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSync sync)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSync *s = _eglLookupSync(sync, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SYNC_KHR, s, EGL_FALSE);
@@ -2156,9 +2118,9 @@ eglDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSync sync)
    if (!(s && (s->Type == EGL_SYNC_NATIVE_FENCE_ANDROID)))
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_NO_NATIVE_FENCE_FD_ANDROID);
 
-   _EGL_CHECK_SYNC(disp, s, EGL_NO_NATIVE_FENCE_FD_ANDROID, drv);
+   _EGL_CHECK_SYNC(disp, s, EGL_NO_NATIVE_FENCE_FD_ANDROID);
    assert(disp->Extensions.ANDROID_native_fence_sync);
-   ret = drv->DupNativeFenceFDANDROID(disp, s);
+   ret = disp->Driver->DupNativeFenceFDANDROID(disp, s);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2170,12 +2132,11 @@ eglSwapBuffersRegionNOK(EGLDisplay dpy, EGLSurface surface,
    _EGLContext *ctx = _eglGetCurrentContext();
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
 
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
 
    if (!disp->Extensions.NOK_swap_region)
       RETURN_EGL_EVAL(disp, EGL_FALSE);
@@ -2185,7 +2146,7 @@ eglSwapBuffersRegionNOK(EGLDisplay dpy, EGLSurface surface,
        surf != ctx->DrawSurface)
       RETURN_EGL_ERROR(disp, EGL_BAD_SURFACE, EGL_FALSE);
 
-   ret = drv->SwapBuffersRegionNOK(disp, surf, numRects, rects);
+   ret = disp->Driver->SwapBuffersRegionNOK(disp, surf, numRects, rects);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2195,17 +2156,16 @@ static EGLImage EGLAPIENTRY
 eglCreateDRMImageMESA(EGLDisplay dpy, const EGLint *attr_list)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
    _EGLImage *img;
    EGLImage ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_NO_IMAGE_KHR);
    if (!disp->Extensions.MESA_drm_image)
       RETURN_EGL_EVAL(disp, EGL_NO_IMAGE_KHR);
 
-   img = drv->CreateDRMImageMESA(disp, attr_list);
+   img = disp->Driver->CreateDRMImageMESA(disp, attr_list);
    ret = (img) ? _eglLinkImage(img) : EGL_NO_IMAGE_KHR;
 
    RETURN_EGL_EVAL(disp, ret);
@@ -2217,18 +2177,17 @@ eglExportDRMImageMESA(EGLDisplay dpy, EGLImage image,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLImage *img = _eglLookupImage(image, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
    assert(disp->Extensions.MESA_drm_image);
 
    if (!img)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->ExportDRMImageMESA(disp, img, name, handle, stride);
+   ret = disp->Driver->ExportDRMImageMESA(disp, img, name, handle, stride);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2240,18 +2199,17 @@ static EGLBoolean EGLAPIENTRY
 eglBindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
    assert(disp->Extensions.WL_bind_wayland_display);
 
    if (!display)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->BindWaylandDisplayWL(disp, display);
+   ret = disp->Driver->BindWaylandDisplayWL(disp, display);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2260,18 +2218,17 @@ static EGLBoolean EGLAPIENTRY
 eglUnbindWaylandDisplayWL(EGLDisplay dpy, struct wl_display *display)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
    assert(disp->Extensions.WL_bind_wayland_display);
 
    if (!display)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->UnbindWaylandDisplayWL(disp, display);
+   ret = disp->Driver->UnbindWaylandDisplayWL(disp, display);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2281,18 +2238,17 @@ eglQueryWaylandBufferWL(EGLDisplay dpy, struct wl_resource *buffer,
                         EGLint attribute, EGLint *value)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
    assert(disp->Extensions.WL_bind_wayland_display);
 
    if (!buffer)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->QueryWaylandBufferWL(disp, buffer, attribute, value);
+   ret = disp->Driver->QueryWaylandBufferWL(disp, buffer, attribute, value);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2303,12 +2259,11 @@ eglCreateWaylandBufferFromImageWL(EGLDisplay dpy, EGLImage image)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLImage *img;
-   const _EGLDriver *drv;
    struct wl_buffer *ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_DISPLAY_KHR, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, NULL, drv);
+   _EGL_CHECK_DISPLAY(disp, NULL);
    if (!disp->Extensions.WL_create_wayland_buffer_from_image)
       RETURN_EGL_EVAL(disp, NULL);
 
@@ -2317,7 +2272,7 @@ eglCreateWaylandBufferFromImageWL(EGLDisplay dpy, EGLImage image)
    if (!img)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, NULL);
 
-   ret = drv->CreateWaylandBufferFromImageWL(disp, img);
+   ret = disp->Driver->CreateWaylandBufferFromImageWL(disp, img);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2328,17 +2283,16 @@ eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
 
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
 
    if (!disp->Extensions.NV_post_sub_buffer)
       RETURN_EGL_EVAL(disp, EGL_FALSE);
 
-   ret = drv->PostSubBufferNV(disp, surf, x, y, width, height);
+   ret = disp->Driver->PostSubBufferNV(disp, surf, x, y, width, height);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2350,19 +2304,18 @@ eglGetSyncValuesCHROMIUM(EGLDisplay dpy, EGLSurface surface,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLSurface *surf = _eglLookupSurface(surface, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_SURFACE_KHR, surf, EGL_FALSE);
 
-   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE, drv);
+   _EGL_CHECK_SURFACE(disp, surf, EGL_FALSE);
    if (!disp->Extensions.CHROMIUM_sync_control)
       RETURN_EGL_EVAL(disp, EGL_FALSE);
 
    if (!ust || !msc || !sbc)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->GetSyncValuesCHROMIUM(disp, surf, ust, msc, sbc);
+   ret = disp->Driver->GetSyncValuesCHROMIUM(disp, surf, ust, msc, sbc);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2374,18 +2327,17 @@ eglExportDMABUFImageQueryMESA(EGLDisplay dpy, EGLImage image,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLImage *img = _eglLookupImage(image, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
    assert(disp->Extensions.MESA_image_dma_buf_export);
 
    if (!img)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->ExportDMABUFImageQueryMESA(disp, img, fourcc, nplanes, modifiers);
+   ret = disp->Driver->ExportDMABUFImageQueryMESA(disp, img, fourcc, nplanes, modifiers);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2396,18 +2348,17 @@ eglExportDMABUFImageMESA(EGLDisplay dpy, EGLImage image,
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
    _EGLImage *img = _eglLookupImage(image, disp);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(disp, EGL_OBJECT_IMAGE_KHR, img, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
    assert(disp->Extensions.MESA_image_dma_buf_export);
 
    if (!img)
       RETURN_EGL_ERROR(disp, EGL_BAD_PARAMETER, EGL_FALSE);
 
-   ret = drv->ExportDMABUFImageMESA(disp, img, fds, strides, offsets);
+   ret = disp->Driver->ExportDMABUFImageMESA(disp, img, fds, strides, offsets);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2564,14 +2515,13 @@ eglQueryDmaBufFormatsEXT(EGLDisplay dpy, EGLint max_formats,
                          EGLint *formats, EGLint *num_formats)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(NULL, EGL_NONE, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
 
-   ret = drv->QueryDmaBufFormatsEXT(disp, max_formats, formats, num_formats);
+   ret = disp->Driver->QueryDmaBufFormatsEXT(disp, max_formats, formats, num_formats);
 
    RETURN_EGL_EVAL(disp, ret);
 }
@@ -2582,14 +2532,13 @@ eglQueryDmaBufModifiersEXT(EGLDisplay dpy, EGLint format, EGLint max_modifiers,
                            EGLint *num_modifiers)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
    EGLBoolean ret;
 
    _EGL_FUNC_START(NULL, EGL_NONE, NULL, EGL_FALSE);
 
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
 
-   ret = drv->QueryDmaBufModifiersEXT(disp, format, max_modifiers, modifiers,
+   ret = disp->Driver->QueryDmaBufModifiersEXT(disp, format, max_modifiers, modifiers,
                                       external_only, num_modifiers);
 
    RETURN_EGL_EVAL(disp, ret);
@@ -2609,8 +2558,7 @@ eglSetBlobCacheFuncsANDROID(EGLDisplay *dpy, EGLSetBlobFuncANDROID set,
       return;
    }
 
-   const _EGLDriver *drv = _eglCheckDisplay(disp, __func__);
-   if (!drv) {
+   if (!_eglCheckDisplay(disp, __func__)) {
       if (disp)
          _eglUnlockDisplay(disp);
       return;
@@ -2633,7 +2581,7 @@ eglSetBlobCacheFuncsANDROID(EGLDisplay *dpy, EGLSetBlobFuncANDROID set,
    disp->BlobCacheSet = set;
    disp->BlobCacheGet = get;
 
-   drv->SetBlobCacheFuncsANDROID(drv, disp, set, get);
+   disp->Driver->SetBlobCacheFuncsANDROID(disp, set, get);
 
    _eglUnlockDisplay(disp);
 }
@@ -2686,10 +2634,9 @@ eglQueryDisplayAttribEXT(EGLDisplay dpy,
                          EGLAttrib *value)
 {
    _EGLDisplay *disp = _eglLockDisplay(dpy);
-   const _EGLDriver *drv;
 
    _EGL_FUNC_START(NULL, EGL_NONE, NULL, EGL_FALSE);
-   _EGL_CHECK_DISPLAY(disp, EGL_FALSE, drv);
+   _EGL_CHECK_DISPLAY(disp, EGL_FALSE);
 
    switch (attribute) {
    case EGL_DEVICE_EXT:
@@ -2705,15 +2652,14 @@ static char * EGLAPIENTRY
 eglGetDisplayDriverConfig(EGLDisplay dpy)
 {
     _EGLDisplay *disp = _eglLockDisplay(dpy);
-    const _EGLDriver *drv;
     char *ret;
 
     _EGL_FUNC_START(disp, EGL_NONE, NULL, NULL);
-    _EGL_CHECK_DISPLAY(disp, NULL, drv);
+    _EGL_CHECK_DISPLAY(disp, NULL);
 
     assert(disp->Extensions.MESA_query_driver);
 
-    ret = drv->QueryDriverConfig(disp);
+    ret = disp->Driver->QueryDriverConfig(disp);
     RETURN_EGL_EVAL(disp, ret);
 }
 
@@ -2721,15 +2667,14 @@ static const char * EGLAPIENTRY
 eglGetDisplayDriverName(EGLDisplay dpy)
 {
     _EGLDisplay *disp = _eglLockDisplay(dpy);
-    const _EGLDriver *drv;
     const char *ret;
 
     _EGL_FUNC_START(disp, EGL_NONE, NULL, NULL);
-    _EGL_CHECK_DISPLAY(disp, NULL, drv);
+    _EGL_CHECK_DISPLAY(disp, NULL);
 
     assert(disp->Extensions.MESA_query_driver);
 
-    ret = drv->QueryDriverName(disp);
+    ret = disp->Driver->QueryDriverName(disp);
     RETURN_EGL_EVAL(disp, ret);
 }
 
@@ -2766,8 +2711,7 @@ eglGetProcAddress(const char *procname)
 
 static int
 _eglLockDisplayInterop(EGLDisplay dpy, EGLContext context,
-                       _EGLDisplay **disp, const _EGLDriver **drv,
-                       _EGLContext **ctx)
+                       _EGLDisplay **disp, _EGLContext **ctx)
 {
 
    *disp = _eglLockDisplay(dpy);
@@ -2777,8 +2721,6 @@ _eglLockDisplayInterop(EGLDisplay dpy, EGLContext context,
       return MESA_GLINTEROP_INVALID_DISPLAY;
    }
 
-   *drv = (*disp)->Driver;
-
    *ctx = _eglLookupContext(context, *disp);
    if (!*ctx ||
        ((*ctx)->ClientAPI != EGL_OPENGL_API &&
@@ -2795,16 +2737,15 @@ MesaGLInteropEGLQueryDeviceInfo(EGLDisplay dpy, EGLContext context,
                                 struct mesa_glinterop_device_info *out)
 {
    _EGLDisplay *disp;
-   const _EGLDriver *drv;
    _EGLContext *ctx;
    int ret;
 
-   ret = _eglLockDisplayInterop(dpy, context, &disp, &drv, &ctx);
+   ret = _eglLockDisplayInterop(dpy, context, &disp, &ctx);
    if (ret != MESA_GLINTEROP_SUCCESS)
       return ret;
 
-   if (drv->GLInteropQueryDeviceInfo)
-      ret = drv->GLInteropQueryDeviceInfo(disp, ctx, out);
+   if (disp->Driver->GLInteropQueryDeviceInfo)
+      ret = disp->Driver->GLInteropQueryDeviceInfo(disp, ctx, out);
    else
       ret = MESA_GLINTEROP_UNSUPPORTED;
 
@@ -2818,16 +2759,15 @@ MesaGLInteropEGLExportObject(EGLDisplay dpy, EGLContext context,
                              struct mesa_glinterop_export_out *out)
 {
    _EGLDisplay *disp;
-   const _EGLDriver *drv;
    _EGLContext *ctx;
    int ret;
 
-   ret = _eglLockDisplayInterop(dpy, context, &disp, &drv, &ctx);
+   ret = _eglLockDisplayInterop(dpy, context, &disp, &ctx);
    if (ret != MESA_GLINTEROP_SUCCESS)
       return ret;
 
-   if (drv->GLInteropExportObject)
-      ret = drv->GLInteropExportObject(disp, ctx, in, out);
+   if (disp->Driver->GLInteropExportObject)
+      ret = disp->Driver->GLInteropExportObject(disp, ctx, in, out);
    else
       ret = MESA_GLINTEROP_UNSUPPORTED;