Add DCHECK for nullptr in gl bindings

ui/gl/gl_bindings_autogen_egl.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 185 matching lines @@
 
   if (g_debugBindingsInitialized)
     InitializeDebugBindings();
 }
 
 extern "C" {
 
 static EGLBoolean GL_BINDING_CALL Debug_eglBindAPI(EGLenum api) {
   GL_SERVICE_LOG("eglBindAPI"
                  << "(" << api << ")");
+  DCHECK(g_driver_egl.debug_fn.eglBindAPIFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglBindAPIFn(api);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglBindTexImage(EGLDisplay dpy,
                                                         EGLSurface surface,
                                                         EGLint buffer) {
   GL_SERVICE_LOG("eglBindTexImage"
                  << "(" << dpy << ", " << surface << ", " << buffer << ")");
+  DCHECK(g_driver_egl.debug_fn.eglBindTexImageFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglBindTexImageFn(dpy, surface, buffer);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL
 Debug_eglChooseConfig(EGLDisplay dpy,
                       const EGLint* attrib_list,
                       EGLConfig* configs,
                       EGLint config_size,
                       EGLint* num_config) {
   GL_SERVICE_LOG("eglChooseConfig"
                  << "(" << dpy << ", " << static_cast<const void*>(attrib_list)
                  << ", " << static_cast<const void*>(configs) << ", "
                  << config_size << ", " << static_cast<const void*>(num_config)
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglChooseConfigFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglChooseConfigFn(
       dpy, attrib_list, configs, config_size, num_config);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLint GL_BINDING_CALL Debug_eglClientWaitSyncKHR(EGLDisplay dpy,
                                                          EGLSyncKHR sync,
                                                          EGLint flags,
                                                          EGLTimeKHR timeout) {
   GL_SERVICE_LOG("eglClientWaitSyncKHR"
                  << "(" << dpy << ", " << sync << ", " << flags << ", "
                  << timeout << ")");
+  DCHECK(g_driver_egl.debug_fn.eglClientWaitSyncKHRFn != nullptr);
   EGLint result =
       g_driver_egl.debug_fn.eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL
 Debug_eglCopyBuffers(EGLDisplay dpy,
                      EGLSurface surface,
                      EGLNativePixmapType target) {
   GL_SERVICE_LOG("eglCopyBuffers"
                  << "(" << dpy << ", " << surface << ", " << target << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCopyBuffersFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglCopyBuffersFn(dpy, surface, target);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLContext GL_BINDING_CALL
 Debug_eglCreateContext(EGLDisplay dpy,
                        EGLConfig config,
                        EGLContext share_context,
                        const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreateContext"
                  << "(" << dpy << ", " << config << ", " << share_context
                  << ", " << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreateContextFn != nullptr);
   EGLContext result = g_driver_egl.debug_fn.eglCreateContextFn(
       dpy, config, share_context, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLImageKHR GL_BINDING_CALL
 Debug_eglCreateImageKHR(EGLDisplay dpy,
                         EGLContext ctx,
                         EGLenum target,
                         EGLClientBuffer buffer,
                         const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreateImageKHR"
                  << "(" << dpy << ", " << ctx << ", " << target << ", "
                  << buffer << ", " << static_cast<const void*>(attrib_list)
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreateImageKHRFn != nullptr);
   EGLImageKHR result = g_driver_egl.debug_fn.eglCreateImageKHRFn(
       dpy, ctx, target, buffer, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLSurface GL_BINDING_CALL
 Debug_eglCreatePbufferFromClientBuffer(EGLDisplay dpy,
                                        EGLenum buftype,
                                        void* buffer,
                                        EGLConfig config,
                                        const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreatePbufferFromClientBuffer"
                  << "(" << dpy << ", " << buftype << ", "
                  << static_cast<const void*>(buffer) << ", " << config << ", "
                  << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreatePbufferFromClientBufferFn != nullptr);
   EGLSurface result = g_driver_egl.debug_fn.eglCreatePbufferFromClientBufferFn(
       dpy, buftype, buffer, config, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLSurface GL_BINDING_CALL
 Debug_eglCreatePbufferSurface(EGLDisplay dpy,
                               EGLConfig config,
                               const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreatePbufferSurface"
                  << "(" << dpy << ", " << config << ", "
                  << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreatePbufferSurfaceFn != nullptr);
   EGLSurface result =
       g_driver_egl.debug_fn.eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLSurface GL_BINDING_CALL
 Debug_eglCreatePixmapSurface(EGLDisplay dpy,
                              EGLConfig config,
                              EGLNativePixmapType pixmap,
                              const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreatePixmapSurface"
                  << "(" << dpy << ", " << config << ", " << pixmap << ", "
                  << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreatePixmapSurfaceFn != nullptr);
   EGLSurface result = g_driver_egl.debug_fn.eglCreatePixmapSurfaceFn(
       dpy, config, pixmap, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLSyncKHR GL_BINDING_CALL
 Debug_eglCreateSyncKHR(EGLDisplay dpy,
                        EGLenum type,
                        const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreateSyncKHR"
                  << "(" << dpy << ", " << type << ", "
                  << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreateSyncKHRFn != nullptr);
   EGLSyncKHR result =
       g_driver_egl.debug_fn.eglCreateSyncKHRFn(dpy, type, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLSurface GL_BINDING_CALL
 Debug_eglCreateWindowSurface(EGLDisplay dpy,
                              EGLConfig config,
                              EGLNativeWindowType win,
                              const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreateWindowSurface"
                  << "(" << dpy << ", " << config << ", " << win << ", "
                  << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglCreateWindowSurfaceFn != nullptr);
   EGLSurface result = g_driver_egl.debug_fn.eglCreateWindowSurfaceFn(
       dpy, config, win, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglDestroyContext(EGLDisplay dpy,
                                                           EGLContext ctx) {
   GL_SERVICE_LOG("eglDestroyContext"
                  << "(" << dpy << ", " << ctx << ")");
+  DCHECK(g_driver_egl.debug_fn.eglDestroyContextFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroyContextFn(dpy, ctx);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglDestroyImageKHR(EGLDisplay dpy,
                                                            EGLImageKHR image) {
   GL_SERVICE_LOG("eglDestroyImageKHR"
                  << "(" << dpy << ", " << image << ")");
+  DCHECK(g_driver_egl.debug_fn.eglDestroyImageKHRFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroyImageKHRFn(dpy, image);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglDestroySurface(EGLDisplay dpy,
                                                           EGLSurface surface) {
   GL_SERVICE_LOG("eglDestroySurface"
                  << "(" << dpy << ", " << surface << ")");
+  DCHECK(g_driver_egl.debug_fn.eglDestroySurfaceFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroySurfaceFn(dpy, surface);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglDestroySyncKHR(EGLDisplay dpy,
                                                           EGLSyncKHR sync) {
   GL_SERVICE_LOG("eglDestroySyncKHR"
                  << "(" << dpy << ", " << sync << ")");
+  DCHECK(g_driver_egl.debug_fn.eglDestroySyncKHRFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglDestroySyncKHRFn(dpy, sync);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglGetConfigAttrib(EGLDisplay dpy,
                                                            EGLConfig config,
                                                            EGLint attribute,
                                                            EGLint* value) {
   GL_SERVICE_LOG("eglGetConfigAttrib"
                  << "(" << dpy << ", " << config << ", " << attribute << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetConfigAttribFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglGetConfigAttribFn(dpy, config, attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglGetConfigs(EGLDisplay dpy,
                                                       EGLConfig* configs,
                                                       EGLint config_size,
                                                       EGLint* num_config) {
   GL_SERVICE_LOG("eglGetConfigs"
                  << "(" << dpy << ", " << static_cast<const void*>(configs)
                  << ", " << config_size << ", "
                  << static_cast<const void*>(num_config) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetConfigsFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglGetConfigsFn(
       dpy, configs, config_size, num_config);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLContext GL_BINDING_CALL Debug_eglGetCurrentContext(void) {
   GL_SERVICE_LOG("eglGetCurrentContext"
                  << "("
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetCurrentContextFn != nullptr);
   EGLContext result = g_driver_egl.debug_fn.eglGetCurrentContextFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLDisplay GL_BINDING_CALL Debug_eglGetCurrentDisplay(void) {
   GL_SERVICE_LOG("eglGetCurrentDisplay"
                  << "("
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetCurrentDisplayFn != nullptr);
   EGLDisplay result = g_driver_egl.debug_fn.eglGetCurrentDisplayFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLSurface GL_BINDING_CALL Debug_eglGetCurrentSurface(EGLint readdraw) {
   GL_SERVICE_LOG("eglGetCurrentSurface"
                  << "(" << readdraw << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetCurrentSurfaceFn != nullptr);
   EGLSurface result = g_driver_egl.debug_fn.eglGetCurrentSurfaceFn(readdraw);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLDisplay GL_BINDING_CALL
 Debug_eglGetDisplay(EGLNativeDisplayType display_id) {
   GL_SERVICE_LOG("eglGetDisplay"
                  << "(" << display_id << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetDisplayFn != nullptr);
   EGLDisplay result = g_driver_egl.debug_fn.eglGetDisplayFn(display_id);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLint GL_BINDING_CALL Debug_eglGetError(void) {
   GL_SERVICE_LOG("eglGetError"
                  << "("
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetErrorFn != nullptr);
   EGLint result = g_driver_egl.debug_fn.eglGetErrorFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLDisplay GL_BINDING_CALL
 Debug_eglGetPlatformDisplayEXT(EGLenum platform,
                                void* native_display,
                                const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglGetPlatformDisplayEXT"
                  << "(" << platform << ", "
                  << static_cast<const void*>(native_display) << ", "
                  << static_cast<const void*>(attrib_list) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetPlatformDisplayEXTFn != nullptr);
   EGLDisplay result = g_driver_egl.debug_fn.eglGetPlatformDisplayEXTFn(
       platform, native_display, attrib_list);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static __eglMustCastToProperFunctionPointerType GL_BINDING_CALL
 Debug_eglGetProcAddress(const char* procname) {
   GL_SERVICE_LOG("eglGetProcAddress"
                  << "(" << procname << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetProcAddressFn != nullptr);
   __eglMustCastToProperFunctionPointerType result =
       g_driver_egl.debug_fn.eglGetProcAddressFn(procname);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglGetSyncAttribKHR(EGLDisplay dpy,
                                                             EGLSyncKHR sync,
                                                             EGLint attribute,
                                                             EGLint* value) {
   GL_SERVICE_LOG("eglGetSyncAttribKHR"
                  << "(" << dpy << ", " << sync << ", " << attribute << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetSyncAttribKHRFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL
 Debug_eglGetSyncValuesCHROMIUM(EGLDisplay dpy,
                                EGLSurface surface,
                                EGLuint64CHROMIUM* ust,
                                EGLuint64CHROMIUM* msc,
                                EGLuint64CHROMIUM* sbc) {
   GL_SERVICE_LOG("eglGetSyncValuesCHROMIUM"
                  << "(" << dpy << ", " << surface << ", "
                  << static_cast<const void*>(ust) << ", "
                  << static_cast<const void*>(msc) << ", "
                  << static_cast<const void*>(sbc) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglGetSyncValuesCHROMIUMFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglGetSyncValuesCHROMIUMFn(
       dpy, surface, ust, msc, sbc);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglInitialize(EGLDisplay dpy,
                                                       EGLint* major,
                                                       EGLint* minor) {
   GL_SERVICE_LOG("eglInitialize"
                  << "(" << dpy << ", " << static_cast<const void*>(major)
                  << ", " << static_cast<const void*>(minor) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglInitializeFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglInitializeFn(dpy, major, minor);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglMakeCurrent(EGLDisplay dpy,
                                                        EGLSurface draw,
                                                        EGLSurface read,
                                                        EGLContext ctx) {
   GL_SERVICE_LOG("eglMakeCurrent"
                  << "(" << dpy << ", " << draw << ", " << read << ", " << ctx
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglMakeCurrentFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglMakeCurrentFn(dpy, draw, read, ctx);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglPostSubBufferNV(EGLDisplay dpy,
                                                            EGLSurface surface,
                                                            EGLint x,
                                                            EGLint y,
                                                            EGLint width,
                                                            EGLint height) {
   GL_SERVICE_LOG("eglPostSubBufferNV"
                  << "(" << dpy << ", " << surface << ", " << x << ", " << y
                  << ", " << width << ", " << height << ")");
+  DCHECK(g_driver_egl.debug_fn.eglPostSubBufferNVFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglPostSubBufferNVFn(
       dpy, surface, x, y, width, height);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLenum GL_BINDING_CALL Debug_eglQueryAPI(void) {
   GL_SERVICE_LOG("eglQueryAPI"
                  << "("
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQueryAPIFn != nullptr);
   EGLenum result = g_driver_egl.debug_fn.eglQueryAPIFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglQueryContext(EGLDisplay dpy,
                                                         EGLContext ctx,
                                                         EGLint attribute,
                                                         EGLint* value) {
   GL_SERVICE_LOG("eglQueryContext"
                  << "(" << dpy << ", " << ctx << ", " << attribute << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQueryContextFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglQueryContextFn(dpy, ctx, attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static const char* GL_BINDING_CALL Debug_eglQueryString(EGLDisplay dpy,
                                                         EGLint name) {
   GL_SERVICE_LOG("eglQueryString"
                  << "(" << dpy << ", " << name << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQueryStringFn != nullptr);
   const char* result = g_driver_egl.debug_fn.eglQueryStringFn(dpy, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglQuerySurface(EGLDisplay dpy,
                                                         EGLSurface surface,
                                                         EGLint attribute,
                                                         EGLint* value) {
   GL_SERVICE_LOG("eglQuerySurface"
                  << "(" << dpy << ", " << surface << ", " << attribute << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQuerySurfaceFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglQuerySurfaceFn(dpy, surface, attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL
 Debug_eglQuerySurfacePointerANGLE(EGLDisplay dpy,
                                   EGLSurface surface,
                                   EGLint attribute,
                                   void** value) {
   GL_SERVICE_LOG("eglQuerySurfacePointerANGLE"
                  << "(" << dpy << ", " << surface << ", " << attribute << ", "
                  << value << ")");
+  DCHECK(g_driver_egl.debug_fn.eglQuerySurfacePointerANGLEFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglQuerySurfacePointerANGLEFn(
       dpy, surface, attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglReleaseTexImage(EGLDisplay dpy,
                                                            EGLSurface surface,
                                                            EGLint buffer) {
   GL_SERVICE_LOG("eglReleaseTexImage"
                  << "(" << dpy << ", " << surface << ", " << buffer << ")");
+  DCHECK(g_driver_egl.debug_fn.eglReleaseTexImageFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglReleaseTexImageFn(dpy, surface, buffer);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglReleaseThread(void) {
   GL_SERVICE_LOG("eglReleaseThread"
                  << "("
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglReleaseThreadFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglReleaseThreadFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglSurfaceAttrib(EGLDisplay dpy,
                                                          EGLSurface surface,
                                                          EGLint attribute,
                                                          EGLint value) {
   GL_SERVICE_LOG("eglSurfaceAttrib"
                  << "(" << dpy << ", " << surface << ", " << attribute << ", "
                  << value << ")");
+  DCHECK(g_driver_egl.debug_fn.eglSurfaceAttribFn != nullptr);
   EGLBoolean result =
       g_driver_egl.debug_fn.eglSurfaceAttribFn(dpy, surface, attribute, value);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglSwapBuffers(EGLDisplay dpy,
                                                        EGLSurface surface) {
   GL_SERVICE_LOG("eglSwapBuffers"
                  << "(" << dpy << ", " << surface << ")");
+  DCHECK(g_driver_egl.debug_fn.eglSwapBuffersFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglSwapBuffersFn(dpy, surface);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglSwapInterval(EGLDisplay dpy,
                                                         EGLint interval) {
   GL_SERVICE_LOG("eglSwapInterval"
                  << "(" << dpy << ", " << interval << ")");
+  DCHECK(g_driver_egl.debug_fn.eglSwapIntervalFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglSwapIntervalFn(dpy, interval);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglTerminate(EGLDisplay dpy) {
   GL_SERVICE_LOG("eglTerminate"
                  << "(" << dpy << ")");
+  DCHECK(g_driver_egl.debug_fn.eglTerminateFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglTerminateFn(dpy);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglWaitClient(void) {
   GL_SERVICE_LOG("eglWaitClient"
                  << "("
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglWaitClientFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglWaitClientFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglWaitGL(void) {
   GL_SERVICE_LOG("eglWaitGL"
                  << "("
                  << ")");
+  DCHECK(g_driver_egl.debug_fn.eglWaitGLFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglWaitGLFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLBoolean GL_BINDING_CALL Debug_eglWaitNative(EGLint engine) {
   GL_SERVICE_LOG("eglWaitNative"
                  << "(" << engine << ")");
+  DCHECK(g_driver_egl.debug_fn.eglWaitNativeFn != nullptr);
   EGLBoolean result = g_driver_egl.debug_fn.eglWaitNativeFn(engine);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static EGLint GL_BINDING_CALL Debug_eglWaitSyncKHR(EGLDisplay dpy,
                                                    EGLSyncKHR sync,
                                                    EGLint flags) {
   GL_SERVICE_LOG("eglWaitSyncKHR"
                  << "(" << dpy << ", " << sync << ", " << flags << ")");
+  DCHECK(g_driver_egl.debug_fn.eglWaitSyncKHRFn != nullptr);
   EGLint result = g_driver_egl.debug_fn.eglWaitSyncKHRFn(dpy, sync, flags);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 }  // extern "C"
 
 void DriverEGL::InitializeDebugBindings() {
   if (!debug_fn.eglBindAPIFn) {
     debug_fn.eglBindAPIFn = fn.eglBindAPIFn;
     fn.eglBindAPIFn = Debug_eglBindAPI;
@@ skipping 745 matching lines @@
 }
 
 EGLint TraceEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
                                      EGLSyncKHR sync,
                                      EGLint flags) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitSyncKHR")
   return egl_api_->eglWaitSyncKHRFn(dpy, sync, flags);
 }
 
 }  // namespace gfx