Add DCHECK for nullptr in gl bindings

ui/gl/gl_bindings_autogen_glx.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file is auto-generated from
 // ui/gl/generate_bindings.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 194 matching lines @@
 extern "C" {
 
 static void GL_BINDING_CALL Debug_glXBindTexImageEXT(Display* dpy,
                                                      GLXDrawable drawable,
                                                      int buffer,
                                                      int* attribList) {
   GL_SERVICE_LOG("glXBindTexImageEXT"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << buffer << ", "
                  << static_cast<const void*>(attribList) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXBindTexImageEXTFn != nullptr);
   g_driver_glx.debug_fn.glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
 }
 
 static GLXFBConfig* GL_BINDING_CALL
 Debug_glXChooseFBConfig(Display* dpy,
                         int screen,
                         const int* attribList,
                         int* nitems) {
   GL_SERVICE_LOG("glXChooseFBConfig"
                  << "(" << static_cast<const void*>(dpy) << ", " << screen
                  << ", " << static_cast<const void*>(attribList) << ", "
                  << static_cast<const void*>(nitems) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXChooseFBConfigFn != nullptr);
   GLXFBConfig* result = g_driver_glx.debug_fn.glXChooseFBConfigFn(
       dpy, screen, attribList, nitems);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static XVisualInfo* GL_BINDING_CALL Debug_glXChooseVisual(Display* dpy,
                                                           int screen,
                                                           int* attribList) {
   GL_SERVICE_LOG("glXChooseVisual"
                  << "(" << static_cast<const void*>(dpy) << ", " << screen
                  << ", " << static_cast<const void*>(attribList) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXChooseVisualFn != nullptr);
   XVisualInfo* result =
       g_driver_glx.debug_fn.glXChooseVisualFn(dpy, screen, attribList);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glXCopyContext(Display* dpy,
                                                  GLXContext src,
                                                  GLXContext dst,
                                                  unsigned long mask) {
   GL_SERVICE_LOG("glXCopyContext"
                  << "(" << static_cast<const void*>(dpy) << ", " << src << ", "
                  << dst << ", " << mask << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCopyContextFn != nullptr);
   g_driver_glx.debug_fn.glXCopyContextFn(dpy, src, dst, mask);
 }
 
 static void GL_BINDING_CALL Debug_glXCopySubBufferMESA(Display* dpy,
                                                        GLXDrawable drawable,
                                                        int x,
                                                        int y,
                                                        int width,
                                                        int height) {
   GL_SERVICE_LOG("glXCopySubBufferMESA"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << x << ", " << y << ", " << width << ", " << height
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCopySubBufferMESAFn != nullptr);
   g_driver_glx.debug_fn.glXCopySubBufferMESAFn(dpy, drawable, x, y, width,
                                                height);
 }
 
 static GLXContext GL_BINDING_CALL Debug_glXCreateContext(Display* dpy,
                                                          XVisualInfo* vis,
                                                          GLXContext shareList,
                                                          int direct) {
   GL_SERVICE_LOG("glXCreateContext"
                  << "(" << static_cast<const void*>(dpy) << ", "
                  << static_cast<const void*>(vis) << ", " << shareList << ", "
                  << direct << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCreateContextFn != nullptr);
   GLXContext result =
       g_driver_glx.debug_fn.glXCreateContextFn(dpy, vis, shareList, direct);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXContext GL_BINDING_CALL
 Debug_glXCreateContextAttribsARB(Display* dpy,
                                  GLXFBConfig config,
                                  GLXContext share_context,
                                  int direct,
                                  const int* attrib_list) {
   GL_SERVICE_LOG("glXCreateContextAttribsARB"
                  << "(" << static_cast<const void*>(dpy) << ", " << config
                  << ", " << share_context << ", " << direct << ", "
                  << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCreateContextAttribsARBFn != nullptr);
   GLXContext result = g_driver_glx.debug_fn.glXCreateContextAttribsARBFn(
       dpy, config, share_context, direct, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXPixmap GL_BINDING_CALL Debug_glXCreateGLXPixmap(Display* dpy,
                                                           XVisualInfo* visual,
                                                           Pixmap pixmap) {
   GL_SERVICE_LOG("glXCreateGLXPixmap"
                  << "(" << static_cast<const void*>(dpy) << ", "
                  << static_cast<const void*>(visual) << ", " << pixmap << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCreateGLXPixmapFn != nullptr);
   GLXPixmap result =
       g_driver_glx.debug_fn.glXCreateGLXPixmapFn(dpy, visual, pixmap);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXContext GL_BINDING_CALL
 Debug_glXCreateNewContext(Display* dpy,
                           GLXFBConfig config,
                           int renderType,
                           GLXContext shareList,
                           int direct) {
   GL_SERVICE_LOG("glXCreateNewContext"
                  << "(" << static_cast<const void*>(dpy) << ", " << config
                  << ", " << renderType << ", " << shareList << ", " << direct
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCreateNewContextFn != nullptr);
   GLXContext result = g_driver_glx.debug_fn.glXCreateNewContextFn(
       dpy, config, renderType, shareList, direct);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXPbuffer GL_BINDING_CALL
 Debug_glXCreatePbuffer(Display* dpy,
                        GLXFBConfig config,
                        const int* attribList) {
   GL_SERVICE_LOG("glXCreatePbuffer"
                  << "(" << static_cast<const void*>(dpy) << ", " << config
                  << ", " << static_cast<const void*>(attribList) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCreatePbufferFn != nullptr);
   GLXPbuffer result =
       g_driver_glx.debug_fn.glXCreatePbufferFn(dpy, config, attribList);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXPixmap GL_BINDING_CALL Debug_glXCreatePixmap(Display* dpy,
                                                        GLXFBConfig config,
                                                        Pixmap pixmap,
                                                        const int* attribList) {
   GL_SERVICE_LOG("glXCreatePixmap"
                  << "(" << static_cast<const void*>(dpy) << ", " << config
                  << ", " << pixmap << ", "
                  << static_cast<const void*>(attribList) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCreatePixmapFn != nullptr);
   GLXPixmap result =
       g_driver_glx.debug_fn.glXCreatePixmapFn(dpy, config, pixmap, attribList);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXWindow GL_BINDING_CALL Debug_glXCreateWindow(Display* dpy,
                                                        GLXFBConfig config,
                                                        Window win,
                                                        const int* attribList) {
   GL_SERVICE_LOG("glXCreateWindow"
                  << "(" << static_cast<const void*>(dpy) << ", " << config
                  << ", " << win << ", " << static_cast<const void*>(attribList)
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXCreateWindowFn != nullptr);
   GLXWindow result =
       g_driver_glx.debug_fn.glXCreateWindowFn(dpy, config, win, attribList);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glXDestroyContext(Display* dpy,
                                                     GLXContext ctx) {
   GL_SERVICE_LOG("glXDestroyContext"
                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
+  DCHECK(g_driver_glx.debug_fn.glXDestroyContextFn != nullptr);
   g_driver_glx.debug_fn.glXDestroyContextFn(dpy, ctx);
 }
 
 static void GL_BINDING_CALL Debug_glXDestroyGLXPixmap(Display* dpy,
                                                       GLXPixmap pixmap) {
   GL_SERVICE_LOG("glXDestroyGLXPixmap"
                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXDestroyGLXPixmapFn != nullptr);
   g_driver_glx.debug_fn.glXDestroyGLXPixmapFn(dpy, pixmap);
 }
 
 static void GL_BINDING_CALL Debug_glXDestroyPbuffer(Display* dpy,
                                                     GLXPbuffer pbuf) {
   GL_SERVICE_LOG("glXDestroyPbuffer"
                  << "(" << static_cast<const void*>(dpy) << ", " << pbuf
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXDestroyPbufferFn != nullptr);
   g_driver_glx.debug_fn.glXDestroyPbufferFn(dpy, pbuf);
 }
 
 static void GL_BINDING_CALL Debug_glXDestroyPixmap(Display* dpy,
                                                    GLXPixmap pixmap) {
   GL_SERVICE_LOG("glXDestroyPixmap"
                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXDestroyPixmapFn != nullptr);
   g_driver_glx.debug_fn.glXDestroyPixmapFn(dpy, pixmap);
 }
 
 static void GL_BINDING_CALL Debug_glXDestroyWindow(Display* dpy,
                                                    GLXWindow window) {
   GL_SERVICE_LOG("glXDestroyWindow"
                  << "(" << static_cast<const void*>(dpy) << ", " << window
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXDestroyWindowFn != nullptr);
   g_driver_glx.debug_fn.glXDestroyWindowFn(dpy, window);
 }
 
 static const char* GL_BINDING_CALL Debug_glXGetClientString(Display* dpy,
                                                             int name) {
   GL_SERVICE_LOG("glXGetClientString"
                  << "(" << static_cast<const void*>(dpy) << ", " << name
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetClientStringFn != nullptr);
   const char* result = g_driver_glx.debug_fn.glXGetClientStringFn(dpy, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static int GL_BINDING_CALL Debug_glXGetConfig(Display* dpy,
                                               XVisualInfo* visual,
                                               int attrib,
                                               int* value) {
   GL_SERVICE_LOG("glXGetConfig"
                  << "(" << static_cast<const void*>(dpy) << ", "
                  << static_cast<const void*>(visual) << ", " << attrib << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetConfigFn != nullptr);
   int result = g_driver_glx.debug_fn.glXGetConfigFn(dpy, visual, attrib, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXContext GL_BINDING_CALL Debug_glXGetCurrentContext(void) {
   GL_SERVICE_LOG("glXGetCurrentContext"
                  << "("
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetCurrentContextFn != nullptr);
   GLXContext result = g_driver_glx.debug_fn.glXGetCurrentContextFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static Display* GL_BINDING_CALL Debug_glXGetCurrentDisplay(void) {
   GL_SERVICE_LOG("glXGetCurrentDisplay"
                  << "("
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetCurrentDisplayFn != nullptr);
   Display* result = g_driver_glx.debug_fn.glXGetCurrentDisplayFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXDrawable GL_BINDING_CALL Debug_glXGetCurrentDrawable(void) {
   GL_SERVICE_LOG("glXGetCurrentDrawable"
                  << "("
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetCurrentDrawableFn != nullptr);
   GLXDrawable result = g_driver_glx.debug_fn.glXGetCurrentDrawableFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXDrawable GL_BINDING_CALL Debug_glXGetCurrentReadDrawable(void) {
   GL_SERVICE_LOG("glXGetCurrentReadDrawable"
                  << "("
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetCurrentReadDrawableFn != nullptr);
   GLXDrawable result = g_driver_glx.debug_fn.glXGetCurrentReadDrawableFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static int GL_BINDING_CALL Debug_glXGetFBConfigAttrib(Display* dpy,
                                                       GLXFBConfig config,
                                                       int attribute,
                                                       int* value) {
   GL_SERVICE_LOG("glXGetFBConfigAttrib"
                  << "(" << static_cast<const void*>(dpy) << ", " << config
                  << ", " << attribute << ", " << static_cast<const void*>(value)
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetFBConfigAttribFn != nullptr);
   int result = g_driver_glx.debug_fn.glXGetFBConfigAttribFn(dpy, config,
                                                             attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXFBConfig GL_BINDING_CALL
 Debug_glXGetFBConfigFromVisualSGIX(Display* dpy, XVisualInfo* visualInfo) {
   GL_SERVICE_LOG("glXGetFBConfigFromVisualSGIX"
                  << "(" << static_cast<const void*>(dpy) << ", "
                  << static_cast<const void*>(visualInfo) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetFBConfigFromVisualSGIXFn != nullptr);
   GLXFBConfig result =
       g_driver_glx.debug_fn.glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLXFBConfig* GL_BINDING_CALL Debug_glXGetFBConfigs(Display* dpy,
                                                           int screen,
                                                           int* nelements) {
   GL_SERVICE_LOG("glXGetFBConfigs"
                  << "(" << static_cast<const void*>(dpy) << ", " << screen
                  << ", " << static_cast<const void*>(nelements) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetFBConfigsFn != nullptr);
   GLXFBConfig* result =
       g_driver_glx.debug_fn.glXGetFBConfigsFn(dpy, screen, nelements);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static bool GL_BINDING_CALL Debug_glXGetMscRateOML(Display* dpy,
                                                    GLXDrawable drawable,
                                                    int32_t* numerator,
                                                    int32_t* denominator) {
   GL_SERVICE_LOG("glXGetMscRateOML"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << static_cast<const void*>(numerator) << ", "
                  << static_cast<const void*>(denominator) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetMscRateOMLFn != nullptr);
   bool result = g_driver_glx.debug_fn.glXGetMscRateOMLFn(
       dpy, drawable, numerator, denominator);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glXGetSelectedEvent(Display* dpy,
                                                       GLXDrawable drawable,
                                                       unsigned long* mask) {
   GL_SERVICE_LOG("glXGetSelectedEvent"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << static_cast<const void*>(mask) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetSelectedEventFn != nullptr);
   g_driver_glx.debug_fn.glXGetSelectedEventFn(dpy, drawable, mask);
 }
 
 static bool GL_BINDING_CALL Debug_glXGetSyncValuesOML(Display* dpy,
                                                       GLXDrawable drawable,
                                                       int64_t* ust,
                                                       int64_t* msc,
                                                       int64_t* sbc) {
   GL_SERVICE_LOG("glXGetSyncValuesOML"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << static_cast<const void*>(ust) << ", "
                  << static_cast<const void*>(msc) << ", "
                  << static_cast<const void*>(sbc) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetSyncValuesOMLFn != nullptr);
   bool result =
       g_driver_glx.debug_fn.glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static XVisualInfo* GL_BINDING_CALL
 Debug_glXGetVisualFromFBConfig(Display* dpy, GLXFBConfig config) {
   GL_SERVICE_LOG("glXGetVisualFromFBConfig"
                  << "(" << static_cast<const void*>(dpy) << ", " << config
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXGetVisualFromFBConfigFn != nullptr);
   XVisualInfo* result =
       g_driver_glx.debug_fn.glXGetVisualFromFBConfigFn(dpy, config);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static int GL_BINDING_CALL Debug_glXIsDirect(Display* dpy, GLXContext ctx) {
   GL_SERVICE_LOG("glXIsDirect"
                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
+  DCHECK(g_driver_glx.debug_fn.glXIsDirectFn != nullptr);
   int result = g_driver_glx.debug_fn.glXIsDirectFn(dpy, ctx);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static int GL_BINDING_CALL Debug_glXMakeContextCurrent(Display* dpy,
                                                        GLXDrawable draw,
                                                        GLXDrawable read,
                                                        GLXContext ctx) {
   GL_SERVICE_LOG("glXMakeContextCurrent"
                  << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
                  << read << ", " << ctx << ")");
+  DCHECK(g_driver_glx.debug_fn.glXMakeContextCurrentFn != nullptr);
   int result =
       g_driver_glx.debug_fn.glXMakeContextCurrentFn(dpy, draw, read, ctx);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static int GL_BINDING_CALL Debug_glXMakeCurrent(Display* dpy,
                                                 GLXDrawable drawable,
                                                 GLXContext ctx) {
   GL_SERVICE_LOG("glXMakeCurrent"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << ctx << ")");
+  DCHECK(g_driver_glx.debug_fn.glXMakeCurrentFn != nullptr);
   int result = g_driver_glx.debug_fn.glXMakeCurrentFn(dpy, drawable, ctx);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static int GL_BINDING_CALL Debug_glXQueryContext(Display* dpy,
                                                  GLXContext ctx,
                                                  int attribute,
                                                  int* value) {
   GL_SERVICE_LOG("glXQueryContext"
                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ", "
                  << attribute << ", " << static_cast<const void*>(value)
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXQueryContextFn != nullptr);
   int result =
       g_driver_glx.debug_fn.glXQueryContextFn(dpy, ctx, attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glXQueryDrawable(Display* dpy,
                                                    GLXDrawable draw,
                                                    int attribute,
                                                    unsigned int* value) {
   GL_SERVICE_LOG("glXQueryDrawable"
                  << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
                  << attribute << ", " << static_cast<const void*>(value)
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXQueryDrawableFn != nullptr);
   g_driver_glx.debug_fn.glXQueryDrawableFn(dpy, draw, attribute, value);
 }
 
 static int GL_BINDING_CALL Debug_glXQueryExtension(Display* dpy,
                                                    int* errorb,
                                                    int* event) {
   GL_SERVICE_LOG("glXQueryExtension"
                  << "(" << static_cast<const void*>(dpy) << ", "
                  << static_cast<const void*>(errorb) << ", "
                  << static_cast<const void*>(event) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXQueryExtensionFn != nullptr);
   int result = g_driver_glx.debug_fn.glXQueryExtensionFn(dpy, errorb, event);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static const char* GL_BINDING_CALL Debug_glXQueryExtensionsString(Display* dpy,
                                                                   int screen) {
   GL_SERVICE_LOG("glXQueryExtensionsString"
                  << "(" << static_cast<const void*>(dpy) << ", " << screen
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXQueryExtensionsStringFn != nullptr);
   const char* result =
       g_driver_glx.debug_fn.glXQueryExtensionsStringFn(dpy, screen);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static const char* GL_BINDING_CALL Debug_glXQueryServerString(Display* dpy,
                                                               int screen,
                                                               int name) {
   GL_SERVICE_LOG("glXQueryServerString"
                  << "(" << static_cast<const void*>(dpy) << ", " << screen
                  << ", " << name << ")");
+  DCHECK(g_driver_glx.debug_fn.glXQueryServerStringFn != nullptr);
   const char* result =
       g_driver_glx.debug_fn.glXQueryServerStringFn(dpy, screen, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static int GL_BINDING_CALL Debug_glXQueryVersion(Display* dpy,
                                                  int* maj,
                                                  int* min) {
   GL_SERVICE_LOG("glXQueryVersion"
                  << "(" << static_cast<const void*>(dpy) << ", "
                  << static_cast<const void*>(maj) << ", "
                  << static_cast<const void*>(min) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXQueryVersionFn != nullptr);
   int result = g_driver_glx.debug_fn.glXQueryVersionFn(dpy, maj, min);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glXReleaseTexImageEXT(Display* dpy,
                                                         GLXDrawable drawable,
                                                         int buffer) {
   GL_SERVICE_LOG("glXReleaseTexImageEXT"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << buffer << ")");
+  DCHECK(g_driver_glx.debug_fn.glXReleaseTexImageEXTFn != nullptr);
   g_driver_glx.debug_fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer);
 }
 
 static void GL_BINDING_CALL Debug_glXSelectEvent(Display* dpy,
                                                  GLXDrawable drawable,
                                                  unsigned long mask) {
   GL_SERVICE_LOG("glXSelectEvent"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << mask << ")");
+  DCHECK(g_driver_glx.debug_fn.glXSelectEventFn != nullptr);
   g_driver_glx.debug_fn.glXSelectEventFn(dpy, drawable, mask);
 }
 
 static void GL_BINDING_CALL Debug_glXSwapBuffers(Display* dpy,
                                                  GLXDrawable drawable) {
   GL_SERVICE_LOG("glXSwapBuffers"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXSwapBuffersFn != nullptr);
   g_driver_glx.debug_fn.glXSwapBuffersFn(dpy, drawable);
 }
 
 static void GL_BINDING_CALL Debug_glXSwapIntervalEXT(Display* dpy,
                                                      GLXDrawable drawable,
                                                      int interval) {
   GL_SERVICE_LOG("glXSwapIntervalEXT"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
                  << ", " << interval << ")");
+  DCHECK(g_driver_glx.debug_fn.glXSwapIntervalEXTFn != nullptr);
   g_driver_glx.debug_fn.glXSwapIntervalEXTFn(dpy, drawable, interval);
 }
 
 static void GL_BINDING_CALL Debug_glXSwapIntervalMESA(unsigned int interval) {
   GL_SERVICE_LOG("glXSwapIntervalMESA"
                  << "(" << interval << ")");
+  DCHECK(g_driver_glx.debug_fn.glXSwapIntervalMESAFn != nullptr);
   g_driver_glx.debug_fn.glXSwapIntervalMESAFn(interval);
 }
 
 static void GL_BINDING_CALL Debug_glXUseXFont(Font font,
                                               int first,
                                               int count,
                                               int list) {
   GL_SERVICE_LOG("glXUseXFont"
                  << "(" << font << ", " << first << ", " << count << ", "
                  << list << ")");
+  DCHECK(g_driver_glx.debug_fn.glXUseXFontFn != nullptr);
   g_driver_glx.debug_fn.glXUseXFontFn(font, first, count, list);
 }
 
 static void GL_BINDING_CALL Debug_glXWaitGL(void) {
   GL_SERVICE_LOG("glXWaitGL"
                  << "("
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXWaitGLFn != nullptr);
   g_driver_glx.debug_fn.glXWaitGLFn();
 }
 
 static int GL_BINDING_CALL Debug_glXWaitVideoSyncSGI(int divisor,
                                                      int remainder,
                                                      unsigned int* count) {
   GL_SERVICE_LOG("glXWaitVideoSyncSGI"
                  << "(" << divisor << ", " << remainder << ", "
                  << static_cast<const void*>(count) << ")");
+  DCHECK(g_driver_glx.debug_fn.glXWaitVideoSyncSGIFn != nullptr);
   int result =
       g_driver_glx.debug_fn.glXWaitVideoSyncSGIFn(divisor, remainder, count);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glXWaitX(void) {
   GL_SERVICE_LOG("glXWaitX"
                  << "("
                  << ")");
+  DCHECK(g_driver_glx.debug_fn.glXWaitXFn != nullptr);
   g_driver_glx.debug_fn.glXWaitXFn();
 }
 }  // extern "C"
 
 void DriverGLX::InitializeDebugBindings() {
   if (!debug_fn.glXBindTexImageEXTFn) {
     debug_fn.glXBindTexImageEXTFn = fn.glXBindTexImageEXTFn;
     fn.glXBindTexImageEXTFn = Debug_glXBindTexImageEXT;
   }
   if (!debug_fn.glXChooseFBConfigFn) {
@@ skipping 778 matching lines @@
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitVideoSyncSGI")
   return glx_api_->glXWaitVideoSyncSGIFn(divisor, remainder, count);
 }
 
 void TraceGLXApi::glXWaitXFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitX")
   glx_api_->glXWaitXFn();
 }
 
 }  // namespace gfx