ui/gl/gl_bindings_autogen_glx.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // This file is auto-generated from
   6 // ui/gl/generate_bindings.py
   7 // It's formatted by clang-format using chromium coding style:
   8 //    clang-format -i -style=chromium filename
   9 // DO NOT EDIT!
  10
  11 #include <string>
  12
  13 #include "base/trace_event/trace_event.h"
  14 #include "ui/gl/gl_bindings.h"
  15 #include "ui/gl/gl_context.h"
  16 #include "ui/gl/gl_enums.h"
  17 #include "ui/gl/gl_glx_api_implementation.h"
  18 #include "ui/gl/gl_implementation.h"
  19 #include "ui/gl/gl_version_info.h"
  20
  21 namespace gfx {
  22
  23 static bool g_debugBindingsInitialized;
  24 DriverGLX g_driver_glx;
  25
  26 void DriverGLX::InitializeStaticBindings() {
  27   fn.glXBindTexImageEXTFn = 0;
  28   fn.glXChooseFBConfigFn = reinterpret_cast<glXChooseFBConfigProc>(
  29       GetGLProcAddress("glXChooseFBConfig"));
  30   fn.glXChooseVisualFn = reinterpret_cast<glXChooseVisualProc>(
  31       GetGLProcAddress("glXChooseVisual"));
  32   fn.glXCopyContextFn =
  33       reinterpret_cast<glXCopyContextProc>(GetGLProcAddress("glXCopyContext"));
  34   fn.glXCopySubBufferMESAFn = 0;
  35   fn.glXCreateContextFn = reinterpret_cast<glXCreateContextProc>(
  36       GetGLProcAddress("glXCreateContext"));
  37   fn.glXCreateContextAttribsARBFn = 0;
  38   fn.glXCreateGLXPixmapFn = reinterpret_cast<glXCreateGLXPixmapProc>(
  39       GetGLProcAddress("glXCreateGLXPixmap"));
  40   fn.glXCreateNewContextFn = reinterpret_cast<glXCreateNewContextProc>(
  41       GetGLProcAddress("glXCreateNewContext"));
  42   fn.glXCreatePbufferFn = reinterpret_cast<glXCreatePbufferProc>(
  43       GetGLProcAddress("glXCreatePbuffer"));
  44   fn.glXCreatePixmapFn = reinterpret_cast<glXCreatePixmapProc>(
  45       GetGLProcAddress("glXCreatePixmap"));
  46   fn.glXCreateWindowFn = reinterpret_cast<glXCreateWindowProc>(
  47       GetGLProcAddress("glXCreateWindow"));
  48   fn.glXDestroyContextFn = reinterpret_cast<glXDestroyContextProc>(
  49       GetGLProcAddress("glXDestroyContext"));
  50   fn.glXDestroyGLXPixmapFn = reinterpret_cast<glXDestroyGLXPixmapProc>(
  51       GetGLProcAddress("glXDestroyGLXPixmap"));
  52   fn.glXDestroyPbufferFn = reinterpret_cast<glXDestroyPbufferProc>(
  53       GetGLProcAddress("glXDestroyPbuffer"));
  54   fn.glXDestroyPixmapFn = reinterpret_cast<glXDestroyPixmapProc>(
  55       GetGLProcAddress("glXDestroyPixmap"));
  56   fn.glXDestroyWindowFn = reinterpret_cast<glXDestroyWindowProc>(
  57       GetGLProcAddress("glXDestroyWindow"));
  58   fn.glXGetClientStringFn = reinterpret_cast<glXGetClientStringProc>(
  59       GetGLProcAddress("glXGetClientString"));
  60   fn.glXGetConfigFn =
  61       reinterpret_cast<glXGetConfigProc>(GetGLProcAddress("glXGetConfig"));
  62   fn.glXGetCurrentContextFn = reinterpret_cast<glXGetCurrentContextProc>(
  63       GetGLProcAddress("glXGetCurrentContext"));
  64   fn.glXGetCurrentDisplayFn = reinterpret_cast<glXGetCurrentDisplayProc>(
  65       GetGLProcAddress("glXGetCurrentDisplay"));
  66   fn.glXGetCurrentDrawableFn = reinterpret_cast<glXGetCurrentDrawableProc>(
  67       GetGLProcAddress("glXGetCurrentDrawable"));
  68   fn.glXGetCurrentReadDrawableFn =
  69       reinterpret_cast<glXGetCurrentReadDrawableProc>(
  70           GetGLProcAddress("glXGetCurrentReadDrawable"));
  71   fn.glXGetFBConfigAttribFn = reinterpret_cast<glXGetFBConfigAttribProc>(
  72       GetGLProcAddress("glXGetFBConfigAttrib"));
  73   fn.glXGetFBConfigFromVisualSGIXFn = 0;
  74   fn.glXGetFBConfigsFn = reinterpret_cast<glXGetFBConfigsProc>(
  75       GetGLProcAddress("glXGetFBConfigs"));
  76   fn.glXGetMscRateOMLFn = 0;
  77   fn.glXGetSelectedEventFn = reinterpret_cast<glXGetSelectedEventProc>(
  78       GetGLProcAddress("glXGetSelectedEvent"));
  79   fn.glXGetSyncValuesOMLFn = 0;
  80   fn.glXGetVisualFromFBConfigFn =
  81       reinterpret_cast<glXGetVisualFromFBConfigProc>(
  82           GetGLProcAddress("glXGetVisualFromFBConfig"));
  83   fn.glXIsDirectFn =
  84       reinterpret_cast<glXIsDirectProc>(GetGLProcAddress("glXIsDirect"));
  85   fn.glXMakeContextCurrentFn = reinterpret_cast<glXMakeContextCurrentProc>(
  86       GetGLProcAddress("glXMakeContextCurrent"));
  87   fn.glXMakeCurrentFn =
  88       reinterpret_cast<glXMakeCurrentProc>(GetGLProcAddress("glXMakeCurrent"));
  89   fn.glXQueryContextFn = reinterpret_cast<glXQueryContextProc>(
  90       GetGLProcAddress("glXQueryContext"));
  91   fn.glXQueryDrawableFn = reinterpret_cast<glXQueryDrawableProc>(
  92       GetGLProcAddress("glXQueryDrawable"));
  93   fn.glXQueryExtensionFn = reinterpret_cast<glXQueryExtensionProc>(
  94       GetGLProcAddress("glXQueryExtension"));
  95   fn.glXQueryExtensionsStringFn =
  96       reinterpret_cast<glXQueryExtensionsStringProc>(
  97           GetGLProcAddress("glXQueryExtensionsString"));
  98   fn.glXQueryServerStringFn = reinterpret_cast<glXQueryServerStringProc>(
  99       GetGLProcAddress("glXQueryServerString"));
 100   fn.glXQueryVersionFn = reinterpret_cast<glXQueryVersionProc>(
 101       GetGLProcAddress("glXQueryVersion"));
 102   fn.glXReleaseTexImageEXTFn = 0;
 103   fn.glXSelectEventFn =
 104       reinterpret_cast<glXSelectEventProc>(GetGLProcAddress("glXSelectEvent"));
 105   fn.glXSwapBuffersFn =
 106       reinterpret_cast<glXSwapBuffersProc>(GetGLProcAddress("glXSwapBuffers"));
 107   fn.glXSwapIntervalEXTFn = 0;
 108   fn.glXSwapIntervalMESAFn = 0;
 109   fn.glXUseXFontFn =
 110       reinterpret_cast<glXUseXFontProc>(GetGLProcAddress("glXUseXFont"));
 111   fn.glXWaitGLFn =
 112       reinterpret_cast<glXWaitGLProc>(GetGLProcAddress("glXWaitGL"));
 113   fn.glXWaitVideoSyncSGIFn = 0;
 114   fn.glXWaitXFn = reinterpret_cast<glXWaitXProc>(GetGLProcAddress("glXWaitX"));
 115 }
 116
 117 void DriverGLX::InitializeExtensionBindings() {
 118   std::string extensions(GetPlatformExtensions());
 119   extensions += " ";
 120   ALLOW_UNUSED_LOCAL(extensions);
 121
 122   ext.b_GLX_ARB_create_context =
 123       extensions.find("GLX_ARB_create_context ") != std::string::npos;
 124   ext.b_GLX_EXT_swap_control =
 125       extensions.find("GLX_EXT_swap_control ") != std::string::npos;
 126   ext.b_GLX_EXT_texture_from_pixmap =
 127       extensions.find("GLX_EXT_texture_from_pixmap ") != std::string::npos;
 128   ext.b_GLX_MESA_copy_sub_buffer =
 129       extensions.find("GLX_MESA_copy_sub_buffer ") != std::string::npos;
 130   ext.b_GLX_MESA_swap_control =
 131       extensions.find("GLX_MESA_swap_control ") != std::string::npos;
 132   ext.b_GLX_OML_sync_control =
 133       extensions.find("GLX_OML_sync_control ") != std::string::npos;
 134   ext.b_GLX_SGIX_fbconfig =
 135       extensions.find("GLX_SGIX_fbconfig ") != std::string::npos;
 136   ext.b_GLX_SGI_video_sync =
 137       extensions.find("GLX_SGI_video_sync ") != std::string::npos;
 138
 139   debug_fn.glXBindTexImageEXTFn = 0;
 140   if (ext.b_GLX_EXT_texture_from_pixmap) {
 141     fn.glXBindTexImageEXTFn = reinterpret_cast<glXBindTexImageEXTProc>(
 142         GetGLProcAddress("glXBindTexImageEXT"));
 143     DCHECK(fn.glXBindTexImageEXTFn);
 144   }
 145
 146   debug_fn.glXCopySubBufferMESAFn = 0;
 147   if (ext.b_GLX_MESA_copy_sub_buffer) {
 148     fn.glXCopySubBufferMESAFn = reinterpret_cast<glXCopySubBufferMESAProc>(
 149         GetGLProcAddress("glXCopySubBufferMESA"));
 150     DCHECK(fn.glXCopySubBufferMESAFn);
 151   }
 152
 153   debug_fn.glXCreateContextAttribsARBFn = 0;
 154   if (ext.b_GLX_ARB_create_context) {
 155     fn.glXCreateContextAttribsARBFn =
 156         reinterpret_cast<glXCreateContextAttribsARBProc>(
 157             GetGLProcAddress("glXCreateContextAttribsARB"));
 158     DCHECK(fn.glXCreateContextAttribsARBFn);
 159   }
 160
 161   debug_fn.glXGetFBConfigFromVisualSGIXFn = 0;
 162   if (ext.b_GLX_SGIX_fbconfig) {
 163     fn.glXGetFBConfigFromVisualSGIXFn =
 164         reinterpret_cast<glXGetFBConfigFromVisualSGIXProc>(
 165             GetGLProcAddress("glXGetFBConfigFromVisualSGIX"));
 166     DCHECK(fn.glXGetFBConfigFromVisualSGIXFn);
 167   }
 168
 169   debug_fn.glXGetMscRateOMLFn = 0;
 170   if (ext.b_GLX_OML_sync_control) {
 171     fn.glXGetMscRateOMLFn = reinterpret_cast<glXGetMscRateOMLProc>(
 172         GetGLProcAddress("glXGetMscRateOML"));
 173     DCHECK(fn.glXGetMscRateOMLFn);
 174   }
 175
 176   debug_fn.glXGetSyncValuesOMLFn = 0;
 177   if (ext.b_GLX_OML_sync_control) {
 178     fn.glXGetSyncValuesOMLFn = reinterpret_cast<glXGetSyncValuesOMLProc>(
 179         GetGLProcAddress("glXGetSyncValuesOML"));
 180     DCHECK(fn.glXGetSyncValuesOMLFn);
 181   }
 182
 183   debug_fn.glXReleaseTexImageEXTFn = 0;
 184   if (ext.b_GLX_EXT_texture_from_pixmap) {
 185     fn.glXReleaseTexImageEXTFn = reinterpret_cast<glXReleaseTexImageEXTProc>(
 186         GetGLProcAddress("glXReleaseTexImageEXT"));
 187     DCHECK(fn.glXReleaseTexImageEXTFn);
 188   }
 189
 190   debug_fn.glXSwapIntervalEXTFn = 0;
 191   if (ext.b_GLX_EXT_swap_control) {
 192     fn.glXSwapIntervalEXTFn = reinterpret_cast<glXSwapIntervalEXTProc>(
 193         GetGLProcAddress("glXSwapIntervalEXT"));
 194     DCHECK(fn.glXSwapIntervalEXTFn);
 195   }
 196
 197   debug_fn.glXSwapIntervalMESAFn = 0;
 198   if (ext.b_GLX_MESA_swap_control) {
 199     fn.glXSwapIntervalMESAFn = reinterpret_cast<glXSwapIntervalMESAProc>(
 200         GetGLProcAddress("glXSwapIntervalMESA"));
 201     DCHECK(fn.glXSwapIntervalMESAFn);
 202   }
 203
 204   debug_fn.glXWaitVideoSyncSGIFn = 0;
 205   if (ext.b_GLX_SGI_video_sync) {
 206     fn.glXWaitVideoSyncSGIFn = reinterpret_cast<glXWaitVideoSyncSGIProc>(
 207         GetGLProcAddress("glXWaitVideoSyncSGI"));
 208     DCHECK(fn.glXWaitVideoSyncSGIFn);
 209   }
 210
 211   if (g_debugBindingsInitialized)
 212     InitializeDebugBindings();
 213 }
 214
 215 extern "C" {
 216
 217 static void GL_BINDING_CALL Debug_glXBindTexImageEXT(Display* dpy,
 218                                                      GLXDrawable drawable,
 219                                                      int buffer,
 220                                                      int* attribList) {
 221   GL_SERVICE_LOG("glXBindTexImageEXT"
 222                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 223                  << ", " << buffer << ", "
 224                  << static_cast<const void*>(attribList) << ")");
 225   g_driver_glx.debug_fn.glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
 226 }
 227
 228 static GLXFBConfig* GL_BINDING_CALL
 229 Debug_glXChooseFBConfig(Display* dpy,
 230                         int screen,
 231                         const int* attribList,
 232                         int* nitems) {
 233   GL_SERVICE_LOG("glXChooseFBConfig"
 234                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 235                  << ", " << static_cast<const void*>(attribList) << ", "
 236                  << static_cast<const void*>(nitems) << ")");
 237   GLXFBConfig* result = g_driver_glx.debug_fn.glXChooseFBConfigFn(
 238       dpy, screen, attribList, nitems);
 239   GL_SERVICE_LOG("GL_RESULT: " << result);
 240   return result;
 241 }
 242
 243 static XVisualInfo* GL_BINDING_CALL
 244 Debug_glXChooseVisual(Display* dpy, int screen, int* attribList) {
 245   GL_SERVICE_LOG("glXChooseVisual"
 246                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 247                  << ", " << static_cast<const void*>(attribList) << ")");
 248   XVisualInfo* result =
 249       g_driver_glx.debug_fn.glXChooseVisualFn(dpy, screen, attribList);
 250   GL_SERVICE_LOG("GL_RESULT: " << result);
 251   return result;
 252 }
 253
 254 static void GL_BINDING_CALL Debug_glXCopyContext(Display* dpy,
 255                                                  GLXContext src,
 256                                                  GLXContext dst,
 257                                                  unsigned long mask) {
 258   GL_SERVICE_LOG("glXCopyContext"
 259                  << "(" << static_cast<const void*>(dpy) << ", " << src << ", "
 260                  << dst << ", " << mask << ")");
 261   g_driver_glx.debug_fn.glXCopyContextFn(dpy, src, dst, mask);
 262 }
 263
 264 static void GL_BINDING_CALL Debug_glXCopySubBufferMESA(Display* dpy,
 265                                                        GLXDrawable drawable,
 266                                                        int x,
 267                                                        int y,
 268                                                        int width,
 269                                                        int height) {
 270   GL_SERVICE_LOG("glXCopySubBufferMESA"
 271                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 272                  << ", " << x << ", " << y << ", " << width << ", " << height
 273                  << ")");
 274   g_driver_glx.debug_fn.glXCopySubBufferMESAFn(dpy, drawable, x, y, width,
 275                                                height);
 276 }
 277
 278 static GLXContext GL_BINDING_CALL Debug_glXCreateContext(Display* dpy,
 279                                                          XVisualInfo* vis,
 280                                                          GLXContext shareList,
 281                                                          int direct) {
 282   GL_SERVICE_LOG("glXCreateContext"
 283                  << "(" << static_cast<const void*>(dpy) << ", "
 284                  << static_cast<const void*>(vis) << ", " << shareList << ", "
 285                  << direct << ")");
 286   GLXContext result =
 287       g_driver_glx.debug_fn.glXCreateContextFn(dpy, vis, shareList, direct);
 288   GL_SERVICE_LOG("GL_RESULT: " << result);
 289   return result;
 290 }
 291
 292 static GLXContext GL_BINDING_CALL
 293 Debug_glXCreateContextAttribsARB(Display* dpy,
 294                                  GLXFBConfig config,
 295                                  GLXContext share_context,
 296                                  int direct,
 297                                  const int* attrib_list) {
 298   GL_SERVICE_LOG("glXCreateContextAttribsARB"
 299                  << "(" << static_cast<const void*>(dpy) << ", " << config
 300                  << ", " << share_context << ", " << direct << ", "
 301                  << static_cast<const void*>(attrib_list) << ")");
 302   GLXContext result = g_driver_glx.debug_fn.glXCreateContextAttribsARBFn(
 303       dpy, config, share_context, direct, attrib_list);
 304   GL_SERVICE_LOG("GL_RESULT: " << result);
 305   return result;
 306 }
 307
 308 static GLXPixmap GL_BINDING_CALL
 309 Debug_glXCreateGLXPixmap(Display* dpy, XVisualInfo* visual, Pixmap pixmap) {
 310   GL_SERVICE_LOG("glXCreateGLXPixmap"
 311                  << "(" << static_cast<const void*>(dpy) << ", "
 312                  << static_cast<const void*>(visual) << ", " << pixmap << ")");
 313   GLXPixmap result =
 314       g_driver_glx.debug_fn.glXCreateGLXPixmapFn(dpy, visual, pixmap);
 315   GL_SERVICE_LOG("GL_RESULT: " << result);
 316   return result;
 317 }
 318
 319 static GLXContext GL_BINDING_CALL
 320 Debug_glXCreateNewContext(Display* dpy,
 321                           GLXFBConfig config,
 322                           int renderType,
 323                           GLXContext shareList,
 324                           int direct) {
 325   GL_SERVICE_LOG("glXCreateNewContext"
 326                  << "(" << static_cast<const void*>(dpy) << ", " << config
 327                  << ", " << renderType << ", " << shareList << ", " << direct
 328                  << ")");
 329   GLXContext result = g_driver_glx.debug_fn.glXCreateNewContextFn(
 330       dpy, config, renderType, shareList, direct);
 331   GL_SERVICE_LOG("GL_RESULT: " << result);
 332   return result;
 333 }
 334
 335 static GLXPbuffer GL_BINDING_CALL
 336 Debug_glXCreatePbuffer(Display* dpy,
 337                        GLXFBConfig config,
 338                        const int* attribList) {
 339   GL_SERVICE_LOG("glXCreatePbuffer"
 340                  << "(" << static_cast<const void*>(dpy) << ", " << config
 341                  << ", " << static_cast<const void*>(attribList) << ")");
 342   GLXPbuffer result =
 343       g_driver_glx.debug_fn.glXCreatePbufferFn(dpy, config, attribList);
 344   GL_SERVICE_LOG("GL_RESULT: " << result);
 345   return result;
 346 }
 347
 348 static GLXPixmap GL_BINDING_CALL Debug_glXCreatePixmap(Display* dpy,
 349                                                        GLXFBConfig config,
 350                                                        Pixmap pixmap,
 351                                                        const int* attribList) {
 352   GL_SERVICE_LOG("glXCreatePixmap"
 353                  << "(" << static_cast<const void*>(dpy) << ", " << config
 354                  << ", " << pixmap << ", "
 355                  << static_cast<const void*>(attribList) << ")");
 356   GLXPixmap result =
 357       g_driver_glx.debug_fn.glXCreatePixmapFn(dpy, config, pixmap, attribList);
 358   GL_SERVICE_LOG("GL_RESULT: " << result);
 359   return result;
 360 }
 361
 362 static GLXWindow GL_BINDING_CALL Debug_glXCreateWindow(Display* dpy,
 363                                                        GLXFBConfig config,
 364                                                        Window win,
 365                                                        const int* attribList) {
 366   GL_SERVICE_LOG("glXCreateWindow"
 367                  << "(" << static_cast<const void*>(dpy) << ", " << config
 368                  << ", " << win << ", " << static_cast<const void*>(attribList)
 369                  << ")");
 370   GLXWindow result =
 371       g_driver_glx.debug_fn.glXCreateWindowFn(dpy, config, win, attribList);
 372   GL_SERVICE_LOG("GL_RESULT: " << result);
 373   return result;
 374 }
 375
 376 static void GL_BINDING_CALL
 377 Debug_glXDestroyContext(Display* dpy, GLXContext ctx) {
 378   GL_SERVICE_LOG("glXDestroyContext"
 379                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
 380   g_driver_glx.debug_fn.glXDestroyContextFn(dpy, ctx);
 381 }
 382
 383 static void GL_BINDING_CALL
 384 Debug_glXDestroyGLXPixmap(Display* dpy, GLXPixmap pixmap) {
 385   GL_SERVICE_LOG("glXDestroyGLXPixmap"
 386                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
 387                  << ")");
 388   g_driver_glx.debug_fn.glXDestroyGLXPixmapFn(dpy, pixmap);
 389 }
 390
 391 static void GL_BINDING_CALL
 392 Debug_glXDestroyPbuffer(Display* dpy, GLXPbuffer pbuf) {
 393   GL_SERVICE_LOG("glXDestroyPbuffer"
 394                  << "(" << static_cast<const void*>(dpy) << ", " << pbuf
 395                  << ")");
 396   g_driver_glx.debug_fn.glXDestroyPbufferFn(dpy, pbuf);
 397 }
 398
 399 static void GL_BINDING_CALL
 400 Debug_glXDestroyPixmap(Display* dpy, GLXPixmap pixmap) {
 401   GL_SERVICE_LOG("glXDestroyPixmap"
 402                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
 403                  << ")");
 404   g_driver_glx.debug_fn.glXDestroyPixmapFn(dpy, pixmap);
 405 }
 406
 407 static void GL_BINDING_CALL
 408 Debug_glXDestroyWindow(Display* dpy, GLXWindow window) {
 409   GL_SERVICE_LOG("glXDestroyWindow"
 410                  << "(" << static_cast<const void*>(dpy) << ", " << window
 411                  << ")");
 412   g_driver_glx.debug_fn.glXDestroyWindowFn(dpy, window);
 413 }
 414
 415 static const char* GL_BINDING_CALL
 416 Debug_glXGetClientString(Display* dpy, int name) {
 417   GL_SERVICE_LOG("glXGetClientString"
 418                  << "(" << static_cast<const void*>(dpy) << ", " << name
 419                  << ")");
 420   const char* result = g_driver_glx.debug_fn.glXGetClientStringFn(dpy, name);
 421   GL_SERVICE_LOG("GL_RESULT: " << result);
 422   return result;
 423 }
 424
 425 static int GL_BINDING_CALL
 426 Debug_glXGetConfig(Display* dpy, XVisualInfo* visual, int attrib, int* value) {
 427   GL_SERVICE_LOG("glXGetConfig"
 428                  << "(" << static_cast<const void*>(dpy) << ", "
 429                  << static_cast<const void*>(visual) << ", " << attrib << ", "
 430                  << static_cast<const void*>(value) << ")");
 431   int result = g_driver_glx.debug_fn.glXGetConfigFn(dpy, visual, attrib, value);
 432   GL_SERVICE_LOG("GL_RESULT: " << result);
 433   return result;
 434 }
 435
 436 static GLXContext GL_BINDING_CALL Debug_glXGetCurrentContext(void) {
 437   GL_SERVICE_LOG("glXGetCurrentContext"
 438                  << "("
 439                  << ")");
 440   GLXContext result = g_driver_glx.debug_fn.glXGetCurrentContextFn();
 441   GL_SERVICE_LOG("GL_RESULT: " << result);
 442   return result;
 443 }
 444
 445 static Display* GL_BINDING_CALL Debug_glXGetCurrentDisplay(void) {
 446   GL_SERVICE_LOG("glXGetCurrentDisplay"
 447                  << "("
 448                  << ")");
 449   Display* result = g_driver_glx.debug_fn.glXGetCurrentDisplayFn();
 450   GL_SERVICE_LOG("GL_RESULT: " << result);
 451   return result;
 452 }
 453
 454 static GLXDrawable GL_BINDING_CALL Debug_glXGetCurrentDrawable(void) {
 455   GL_SERVICE_LOG("glXGetCurrentDrawable"
 456                  << "("
 457                  << ")");
 458   GLXDrawable result = g_driver_glx.debug_fn.glXGetCurrentDrawableFn();
 459   GL_SERVICE_LOG("GL_RESULT: " << result);
 460   return result;
 461 }
 462
 463 static GLXDrawable GL_BINDING_CALL Debug_glXGetCurrentReadDrawable(void) {
 464   GL_SERVICE_LOG("glXGetCurrentReadDrawable"
 465                  << "("
 466                  << ")");
 467   GLXDrawable result = g_driver_glx.debug_fn.glXGetCurrentReadDrawableFn();
 468   GL_SERVICE_LOG("GL_RESULT: " << result);
 469   return result;
 470 }
 471
 472 static int GL_BINDING_CALL Debug_glXGetFBConfigAttrib(Display* dpy,
 473                                                       GLXFBConfig config,
 474                                                       int attribute,
 475                                                       int* value) {
 476   GL_SERVICE_LOG("glXGetFBConfigAttrib"
 477                  << "(" << static_cast<const void*>(dpy) << ", " << config
 478                  << ", " << attribute << ", " << static_cast<const void*>(value)
 479                  << ")");
 480   int result = g_driver_glx.debug_fn.glXGetFBConfigAttribFn(dpy, config,
 481                                                             attribute, value);
 482   GL_SERVICE_LOG("GL_RESULT: " << result);
 483   return result;
 484 }
 485
 486 static GLXFBConfig GL_BINDING_CALL
 487 Debug_glXGetFBConfigFromVisualSGIX(Display* dpy, XVisualInfo* visualInfo) {
 488   GL_SERVICE_LOG("glXGetFBConfigFromVisualSGIX"
 489                  << "(" << static_cast<const void*>(dpy) << ", "
 490                  << static_cast<const void*>(visualInfo) << ")");
 491   GLXFBConfig result =
 492       g_driver_glx.debug_fn.glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
 493   GL_SERVICE_LOG("GL_RESULT: " << result);
 494   return result;
 495 }
 496
 497 static GLXFBConfig* GL_BINDING_CALL
 498 Debug_glXGetFBConfigs(Display* dpy, int screen, int* nelements) {
 499   GL_SERVICE_LOG("glXGetFBConfigs"
 500                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 501                  << ", " << static_cast<const void*>(nelements) << ")");
 502   GLXFBConfig* result =
 503       g_driver_glx.debug_fn.glXGetFBConfigsFn(dpy, screen, nelements);
 504   GL_SERVICE_LOG("GL_RESULT: " << result);
 505   return result;
 506 }
 507
 508 static bool GL_BINDING_CALL Debug_glXGetMscRateOML(Display* dpy,
 509                                                    GLXDrawable drawable,
 510                                                    int32* numerator,
 511                                                    int32* denominator) {
 512   GL_SERVICE_LOG("glXGetMscRateOML"
 513                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 514                  << ", " << static_cast<const void*>(numerator) << ", "
 515                  << static_cast<const void*>(denominator) << ")");
 516   bool result = g_driver_glx.debug_fn.glXGetMscRateOMLFn(
 517       dpy, drawable, numerator, denominator);
 518   GL_SERVICE_LOG("GL_RESULT: " << result);
 519   return result;
 520 }
 521
 522 static void GL_BINDING_CALL Debug_glXGetSelectedEvent(Display* dpy,
 523                                                       GLXDrawable drawable,
 524                                                       unsigned long* mask) {
 525   GL_SERVICE_LOG("glXGetSelectedEvent"
 526                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 527                  << ", " << static_cast<const void*>(mask) << ")");
 528   g_driver_glx.debug_fn.glXGetSelectedEventFn(dpy, drawable, mask);
 529 }
 530
 531 static bool GL_BINDING_CALL Debug_glXGetSyncValuesOML(Display* dpy,
 532                                                       GLXDrawable drawable,
 533                                                       int64* ust,
 534                                                       int64* msc,
 535                                                       int64* sbc) {
 536   GL_SERVICE_LOG("glXGetSyncValuesOML"
 537                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 538                  << ", " << static_cast<const void*>(ust) << ", "
 539                  << static_cast<const void*>(msc) << ", "
 540                  << static_cast<const void*>(sbc) << ")");
 541   bool result =
 542       g_driver_glx.debug_fn.glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
 543   GL_SERVICE_LOG("GL_RESULT: " << result);
 544   return result;
 545 }
 546
 547 static XVisualInfo* GL_BINDING_CALL
 548 Debug_glXGetVisualFromFBConfig(Display* dpy, GLXFBConfig config) {
 549   GL_SERVICE_LOG("glXGetVisualFromFBConfig"
 550                  << "(" << static_cast<const void*>(dpy) << ", " << config
 551                  << ")");
 552   XVisualInfo* result =
 553       g_driver_glx.debug_fn.glXGetVisualFromFBConfigFn(dpy, config);
 554   GL_SERVICE_LOG("GL_RESULT: " << result);
 555   return result;
 556 }
 557
 558 static int GL_BINDING_CALL Debug_glXIsDirect(Display* dpy, GLXContext ctx) {
 559   GL_SERVICE_LOG("glXIsDirect"
 560                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
 561   int result = g_driver_glx.debug_fn.glXIsDirectFn(dpy, ctx);
 562   GL_SERVICE_LOG("GL_RESULT: " << result);
 563   return result;
 564 }
 565
 566 static int GL_BINDING_CALL Debug_glXMakeContextCurrent(Display* dpy,
 567                                                        GLXDrawable draw,
 568                                                        GLXDrawable read,
 569                                                        GLXContext ctx) {
 570   GL_SERVICE_LOG("glXMakeContextCurrent"
 571                  << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
 572                  << read << ", " << ctx << ")");
 573   int result =
 574       g_driver_glx.debug_fn.glXMakeContextCurrentFn(dpy, draw, read, ctx);
 575   GL_SERVICE_LOG("GL_RESULT: " << result);
 576   return result;
 577 }
 578
 579 static int GL_BINDING_CALL
 580 Debug_glXMakeCurrent(Display* dpy, GLXDrawable drawable, GLXContext ctx) {
 581   GL_SERVICE_LOG("glXMakeCurrent"
 582                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 583                  << ", " << ctx << ")");
 584   int result = g_driver_glx.debug_fn.glXMakeCurrentFn(dpy, drawable, ctx);
 585   GL_SERVICE_LOG("GL_RESULT: " << result);
 586   return result;
 587 }
 588
 589 static int GL_BINDING_CALL
 590 Debug_glXQueryContext(Display* dpy, GLXContext ctx, int attribute, int* value) {
 591   GL_SERVICE_LOG("glXQueryContext"
 592                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ", "
 593                  << attribute << ", " << static_cast<const void*>(value)
 594                  << ")");
 595   int result =
 596       g_driver_glx.debug_fn.glXQueryContextFn(dpy, ctx, attribute, value);
 597   GL_SERVICE_LOG("GL_RESULT: " << result);
 598   return result;
 599 }
 600
 601 static void GL_BINDING_CALL Debug_glXQueryDrawable(Display* dpy,
 602                                                    GLXDrawable draw,
 603                                                    int attribute,
 604                                                    unsigned int* value) {
 605   GL_SERVICE_LOG("glXQueryDrawable"
 606                  << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
 607                  << attribute << ", " << static_cast<const void*>(value)
 608                  << ")");
 609   g_driver_glx.debug_fn.glXQueryDrawableFn(dpy, draw, attribute, value);
 610 }
 611
 612 static int GL_BINDING_CALL
 613 Debug_glXQueryExtension(Display* dpy, int* errorb, int* event) {
 614   GL_SERVICE_LOG("glXQueryExtension"
 615                  << "(" << static_cast<const void*>(dpy) << ", "
 616                  << static_cast<const void*>(errorb) << ", "
 617                  << static_cast<const void*>(event) << ")");
 618   int result = g_driver_glx.debug_fn.glXQueryExtensionFn(dpy, errorb, event);
 619   GL_SERVICE_LOG("GL_RESULT: " << result);
 620   return result;
 621 }
 622
 623 static const char* GL_BINDING_CALL
 624 Debug_glXQueryExtensionsString(Display* dpy, int screen) {
 625   GL_SERVICE_LOG("glXQueryExtensionsString"
 626                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 627                  << ")");
 628   const char* result =
 629       g_driver_glx.debug_fn.glXQueryExtensionsStringFn(dpy, screen);
 630   GL_SERVICE_LOG("GL_RESULT: " << result);
 631   return result;
 632 }
 633
 634 static const char* GL_BINDING_CALL
 635 Debug_glXQueryServerString(Display* dpy, int screen, int name) {
 636   GL_SERVICE_LOG("glXQueryServerString"
 637                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 638                  << ", " << name << ")");
 639   const char* result =
 640       g_driver_glx.debug_fn.glXQueryServerStringFn(dpy, screen, name);
 641   GL_SERVICE_LOG("GL_RESULT: " << result);
 642   return result;
 643 }
 644
 645 static int GL_BINDING_CALL
 646 Debug_glXQueryVersion(Display* dpy, int* maj, int* min) {
 647   GL_SERVICE_LOG("glXQueryVersion"
 648                  << "(" << static_cast<const void*>(dpy) << ", "
 649                  << static_cast<const void*>(maj) << ", "
 650                  << static_cast<const void*>(min) << ")");
 651   int result = g_driver_glx.debug_fn.glXQueryVersionFn(dpy, maj, min);
 652   GL_SERVICE_LOG("GL_RESULT: " << result);
 653   return result;
 654 }
 655
 656 static void GL_BINDING_CALL
 657 Debug_glXReleaseTexImageEXT(Display* dpy, GLXDrawable drawable, int buffer) {
 658   GL_SERVICE_LOG("glXReleaseTexImageEXT"
 659                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 660                  << ", " << buffer << ")");
 661   g_driver_glx.debug_fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer);
 662 }
 663
 664 static void GL_BINDING_CALL
 665 Debug_glXSelectEvent(Display* dpy, GLXDrawable drawable, unsigned long mask) {
 666   GL_SERVICE_LOG("glXSelectEvent"
 667                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 668                  << ", " << mask << ")");
 669   g_driver_glx.debug_fn.glXSelectEventFn(dpy, drawable, mask);
 670 }
 671
 672 static void GL_BINDING_CALL
 673 Debug_glXSwapBuffers(Display* dpy, GLXDrawable drawable) {
 674   GL_SERVICE_LOG("glXSwapBuffers"
 675                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 676                  << ")");
 677   g_driver_glx.debug_fn.glXSwapBuffersFn(dpy, drawable);
 678 }
 679
 680 static void GL_BINDING_CALL
 681 Debug_glXSwapIntervalEXT(Display* dpy, GLXDrawable drawable, int interval) {
 682   GL_SERVICE_LOG("glXSwapIntervalEXT"
 683                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 684                  << ", " << interval << ")");
 685   g_driver_glx.debug_fn.glXSwapIntervalEXTFn(dpy, drawable, interval);
 686 }
 687
 688 static void GL_BINDING_CALL Debug_glXSwapIntervalMESA(unsigned int interval) {
 689   GL_SERVICE_LOG("glXSwapIntervalMESA"
 690                  << "(" << interval << ")");
 691   g_driver_glx.debug_fn.glXSwapIntervalMESAFn(interval);
 692 }
 693
 694 static void GL_BINDING_CALL
 695 Debug_glXUseXFont(Font font, int first, int count, int list) {
 696   GL_SERVICE_LOG("glXUseXFont"
 697                  << "(" << font << ", " << first << ", " << count << ", "
 698                  << list << ")");
 699   g_driver_glx.debug_fn.glXUseXFontFn(font, first, count, list);
 700 }
 701
 702 static void GL_BINDING_CALL Debug_glXWaitGL(void) {
 703   GL_SERVICE_LOG("glXWaitGL"
 704                  << "("
 705                  << ")");
 706   g_driver_glx.debug_fn.glXWaitGLFn();
 707 }
 708
 709 static int GL_BINDING_CALL
 710 Debug_glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int* count) {
 711   GL_SERVICE_LOG("glXWaitVideoSyncSGI"
 712                  << "(" << divisor << ", " << remainder << ", "
 713                  << static_cast<const void*>(count) << ")");
 714   int result =
 715       g_driver_glx.debug_fn.glXWaitVideoSyncSGIFn(divisor, remainder, count);
 716   GL_SERVICE_LOG("GL_RESULT: " << result);
 717   return result;
 718 }
 719
 720 static void GL_BINDING_CALL Debug_glXWaitX(void) {
 721   GL_SERVICE_LOG("glXWaitX"
 722                  << "("
 723                  << ")");
 724   g_driver_glx.debug_fn.glXWaitXFn();
 725 }
 726 }  // extern "C"
 727
 728 void DriverGLX::InitializeDebugBindings() {
 729   if (!debug_fn.glXBindTexImageEXTFn) {
 730     debug_fn.glXBindTexImageEXTFn = fn.glXBindTexImageEXTFn;
 731     fn.glXBindTexImageEXTFn = Debug_glXBindTexImageEXT;
 732   }
 733   if (!debug_fn.glXChooseFBConfigFn) {
 734     debug_fn.glXChooseFBConfigFn = fn.glXChooseFBConfigFn;
 735     fn.glXChooseFBConfigFn = Debug_glXChooseFBConfig;
 736   }
 737   if (!debug_fn.glXChooseVisualFn) {
 738     debug_fn.glXChooseVisualFn = fn.glXChooseVisualFn;
 739     fn.glXChooseVisualFn = Debug_glXChooseVisual;
 740   }
 741   if (!debug_fn.glXCopyContextFn) {
 742     debug_fn.glXCopyContextFn = fn.glXCopyContextFn;
 743     fn.glXCopyContextFn = Debug_glXCopyContext;
 744   }
 745   if (!debug_fn.glXCopySubBufferMESAFn) {
 746     debug_fn.glXCopySubBufferMESAFn = fn.glXCopySubBufferMESAFn;
 747     fn.glXCopySubBufferMESAFn = Debug_glXCopySubBufferMESA;
 748   }
 749   if (!debug_fn.glXCreateContextFn) {
 750     debug_fn.glXCreateContextFn = fn.glXCreateContextFn;
 751     fn.glXCreateContextFn = Debug_glXCreateContext;
 752   }
 753   if (!debug_fn.glXCreateContextAttribsARBFn) {
 754     debug_fn.glXCreateContextAttribsARBFn = fn.glXCreateContextAttribsARBFn;
 755     fn.glXCreateContextAttribsARBFn = Debug_glXCreateContextAttribsARB;
 756   }
 757   if (!debug_fn.glXCreateGLXPixmapFn) {
 758     debug_fn.glXCreateGLXPixmapFn = fn.glXCreateGLXPixmapFn;
 759     fn.glXCreateGLXPixmapFn = Debug_glXCreateGLXPixmap;
 760   }
 761   if (!debug_fn.glXCreateNewContextFn) {
 762     debug_fn.glXCreateNewContextFn = fn.glXCreateNewContextFn;
 763     fn.glXCreateNewContextFn = Debug_glXCreateNewContext;
 764   }
 765   if (!debug_fn.glXCreatePbufferFn) {
 766     debug_fn.glXCreatePbufferFn = fn.glXCreatePbufferFn;
 767     fn.glXCreatePbufferFn = Debug_glXCreatePbuffer;
 768   }
 769   if (!debug_fn.glXCreatePixmapFn) {
 770     debug_fn.glXCreatePixmapFn = fn.glXCreatePixmapFn;
 771     fn.glXCreatePixmapFn = Debug_glXCreatePixmap;
 772   }
 773   if (!debug_fn.glXCreateWindowFn) {
 774     debug_fn.glXCreateWindowFn = fn.glXCreateWindowFn;
 775     fn.glXCreateWindowFn = Debug_glXCreateWindow;
 776   }
 777   if (!debug_fn.glXDestroyContextFn) {
 778     debug_fn.glXDestroyContextFn = fn.glXDestroyContextFn;
 779     fn.glXDestroyContextFn = Debug_glXDestroyContext;
 780   }
 781   if (!debug_fn.glXDestroyGLXPixmapFn) {
 782     debug_fn.glXDestroyGLXPixmapFn = fn.glXDestroyGLXPixmapFn;
 783     fn.glXDestroyGLXPixmapFn = Debug_glXDestroyGLXPixmap;
 784   }
 785   if (!debug_fn.glXDestroyPbufferFn) {
 786     debug_fn.glXDestroyPbufferFn = fn.glXDestroyPbufferFn;
 787     fn.glXDestroyPbufferFn = Debug_glXDestroyPbuffer;
 788   }
 789   if (!debug_fn.glXDestroyPixmapFn) {
 790     debug_fn.glXDestroyPixmapFn = fn.glXDestroyPixmapFn;
 791     fn.glXDestroyPixmapFn = Debug_glXDestroyPixmap;
 792   }
 793   if (!debug_fn.glXDestroyWindowFn) {
 794     debug_fn.glXDestroyWindowFn = fn.glXDestroyWindowFn;
 795     fn.glXDestroyWindowFn = Debug_glXDestroyWindow;
 796   }
 797   if (!debug_fn.glXGetClientStringFn) {
 798     debug_fn.glXGetClientStringFn = fn.glXGetClientStringFn;
 799     fn.glXGetClientStringFn = Debug_glXGetClientString;
 800   }
 801   if (!debug_fn.glXGetConfigFn) {
 802     debug_fn.glXGetConfigFn = fn.glXGetConfigFn;
 803     fn.glXGetConfigFn = Debug_glXGetConfig;
 804   }
 805   if (!debug_fn.glXGetCurrentContextFn) {
 806     debug_fn.glXGetCurrentContextFn = fn.glXGetCurrentContextFn;
 807     fn.glXGetCurrentContextFn = Debug_glXGetCurrentContext;
 808   }
 809   if (!debug_fn.glXGetCurrentDisplayFn) {
 810     debug_fn.glXGetCurrentDisplayFn = fn.glXGetCurrentDisplayFn;
 811     fn.glXGetCurrentDisplayFn = Debug_glXGetCurrentDisplay;
 812   }
 813   if (!debug_fn.glXGetCurrentDrawableFn) {
 814     debug_fn.glXGetCurrentDrawableFn = fn.glXGetCurrentDrawableFn;
 815     fn.glXGetCurrentDrawableFn = Debug_glXGetCurrentDrawable;
 816   }
 817   if (!debug_fn.glXGetCurrentReadDrawableFn) {
 818     debug_fn.glXGetCurrentReadDrawableFn = fn.glXGetCurrentReadDrawableFn;
 819     fn.glXGetCurrentReadDrawableFn = Debug_glXGetCurrentReadDrawable;
 820   }
 821   if (!debug_fn.glXGetFBConfigAttribFn) {
 822     debug_fn.glXGetFBConfigAttribFn = fn.glXGetFBConfigAttribFn;
 823     fn.glXGetFBConfigAttribFn = Debug_glXGetFBConfigAttrib;
 824   }
 825   if (!debug_fn.glXGetFBConfigFromVisualSGIXFn) {
 826     debug_fn.glXGetFBConfigFromVisualSGIXFn = fn.glXGetFBConfigFromVisualSGIXFn;
 827     fn.glXGetFBConfigFromVisualSGIXFn = Debug_glXGetFBConfigFromVisualSGIX;
 828   }
 829   if (!debug_fn.glXGetFBConfigsFn) {
 830     debug_fn.glXGetFBConfigsFn = fn.glXGetFBConfigsFn;
 831     fn.glXGetFBConfigsFn = Debug_glXGetFBConfigs;
 832   }
 833   if (!debug_fn.glXGetMscRateOMLFn) {
 834     debug_fn.glXGetMscRateOMLFn = fn.glXGetMscRateOMLFn;
 835     fn.glXGetMscRateOMLFn = Debug_glXGetMscRateOML;
 836   }
 837   if (!debug_fn.glXGetSelectedEventFn) {
 838     debug_fn.glXGetSelectedEventFn = fn.glXGetSelectedEventFn;
 839     fn.glXGetSelectedEventFn = Debug_glXGetSelectedEvent;
 840   }
 841   if (!debug_fn.glXGetSyncValuesOMLFn) {
 842     debug_fn.glXGetSyncValuesOMLFn = fn.glXGetSyncValuesOMLFn;
 843     fn.glXGetSyncValuesOMLFn = Debug_glXGetSyncValuesOML;
 844   }
 845   if (!debug_fn.glXGetVisualFromFBConfigFn) {
 846     debug_fn.glXGetVisualFromFBConfigFn = fn.glXGetVisualFromFBConfigFn;
 847     fn.glXGetVisualFromFBConfigFn = Debug_glXGetVisualFromFBConfig;
 848   }
 849   if (!debug_fn.glXIsDirectFn) {
 850     debug_fn.glXIsDirectFn = fn.glXIsDirectFn;
 851     fn.glXIsDirectFn = Debug_glXIsDirect;
 852   }
 853   if (!debug_fn.glXMakeContextCurrentFn) {
 854     debug_fn.glXMakeContextCurrentFn = fn.glXMakeContextCurrentFn;
 855     fn.glXMakeContextCurrentFn = Debug_glXMakeContextCurrent;
 856   }
 857   if (!debug_fn.glXMakeCurrentFn) {
 858     debug_fn.glXMakeCurrentFn = fn.glXMakeCurrentFn;
 859     fn.glXMakeCurrentFn = Debug_glXMakeCurrent;
 860   }
 861   if (!debug_fn.glXQueryContextFn) {
 862     debug_fn.glXQueryContextFn = fn.glXQueryContextFn;
 863     fn.glXQueryContextFn = Debug_glXQueryContext;
 864   }
 865   if (!debug_fn.glXQueryDrawableFn) {
 866     debug_fn.glXQueryDrawableFn = fn.glXQueryDrawableFn;
 867     fn.glXQueryDrawableFn = Debug_glXQueryDrawable;
 868   }
 869   if (!debug_fn.glXQueryExtensionFn) {
 870     debug_fn.glXQueryExtensionFn = fn.glXQueryExtensionFn;
 871     fn.glXQueryExtensionFn = Debug_glXQueryExtension;
 872   }
 873   if (!debug_fn.glXQueryExtensionsStringFn) {
 874     debug_fn.glXQueryExtensionsStringFn = fn.glXQueryExtensionsStringFn;
 875     fn.glXQueryExtensionsStringFn = Debug_glXQueryExtensionsString;
 876   }
 877   if (!debug_fn.glXQueryServerStringFn) {
 878     debug_fn.glXQueryServerStringFn = fn.glXQueryServerStringFn;
 879     fn.glXQueryServerStringFn = Debug_glXQueryServerString;
 880   }
 881   if (!debug_fn.glXQueryVersionFn) {
 882     debug_fn.glXQueryVersionFn = fn.glXQueryVersionFn;
 883     fn.glXQueryVersionFn = Debug_glXQueryVersion;
 884   }
 885   if (!debug_fn.glXReleaseTexImageEXTFn) {
 886     debug_fn.glXReleaseTexImageEXTFn = fn.glXReleaseTexImageEXTFn;
 887     fn.glXReleaseTexImageEXTFn = Debug_glXReleaseTexImageEXT;
 888   }
 889   if (!debug_fn.glXSelectEventFn) {
 890     debug_fn.glXSelectEventFn = fn.glXSelectEventFn;
 891     fn.glXSelectEventFn = Debug_glXSelectEvent;
 892   }
 893   if (!debug_fn.glXSwapBuffersFn) {
 894     debug_fn.glXSwapBuffersFn = fn.glXSwapBuffersFn;
 895     fn.glXSwapBuffersFn = Debug_glXSwapBuffers;
 896   }
 897   if (!debug_fn.glXSwapIntervalEXTFn) {
 898     debug_fn.glXSwapIntervalEXTFn = fn.glXSwapIntervalEXTFn;
 899     fn.glXSwapIntervalEXTFn = Debug_glXSwapIntervalEXT;
 900   }
 901   if (!debug_fn.glXSwapIntervalMESAFn) {
 902     debug_fn.glXSwapIntervalMESAFn = fn.glXSwapIntervalMESAFn;
 903     fn.glXSwapIntervalMESAFn = Debug_glXSwapIntervalMESA;
 904   }
 905   if (!debug_fn.glXUseXFontFn) {
 906     debug_fn.glXUseXFontFn = fn.glXUseXFontFn;
 907     fn.glXUseXFontFn = Debug_glXUseXFont;
 908   }
 909   if (!debug_fn.glXWaitGLFn) {
 910     debug_fn.glXWaitGLFn = fn.glXWaitGLFn;
 911     fn.glXWaitGLFn = Debug_glXWaitGL;
 912   }
 913   if (!debug_fn.glXWaitVideoSyncSGIFn) {
 914     debug_fn.glXWaitVideoSyncSGIFn = fn.glXWaitVideoSyncSGIFn;
 915     fn.glXWaitVideoSyncSGIFn = Debug_glXWaitVideoSyncSGI;
 916   }
 917   if (!debug_fn.glXWaitXFn) {
 918     debug_fn.glXWaitXFn = fn.glXWaitXFn;
 919     fn.glXWaitXFn = Debug_glXWaitX;
 920   }
 921   g_debugBindingsInitialized = true;
 922 }
 923
 924 void DriverGLX::ClearBindings() {
 925   memset(this, 0, sizeof(*this));
 926 }
 927
 928 void GLXApiBase::glXBindTexImageEXTFn(Display* dpy,
 929                                       GLXDrawable drawable,
 930                                       int buffer,
 931                                       int* attribList) {
 932   driver_->fn.glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
 933 }
 934
 935 GLXFBConfig* GLXApiBase::glXChooseFBConfigFn(Display* dpy,
 936                                              int screen,
 937                                              const int* attribList,
 938                                              int* nitems) {
 939   return driver_->fn.glXChooseFBConfigFn(dpy, screen, attribList, nitems);
 940 }
 941
 942 XVisualInfo* GLXApiBase::glXChooseVisualFn(Display* dpy,
 943                                            int screen,
 944                                            int* attribList) {
 945   return driver_->fn.glXChooseVisualFn(dpy, screen, attribList);
 946 }
 947
 948 void GLXApiBase::glXCopyContextFn(Display* dpy,
 949                                   GLXContext src,
 950                                   GLXContext dst,
 951                                   unsigned long mask) {
 952   driver_->fn.glXCopyContextFn(dpy, src, dst, mask);
 953 }
 954
 955 void GLXApiBase::glXCopySubBufferMESAFn(Display* dpy,
 956                                         GLXDrawable drawable,
 957                                         int x,
 958                                         int y,
 959                                         int width,
 960                                         int height) {
 961   driver_->fn.glXCopySubBufferMESAFn(dpy, drawable, x, y, width, height);
 962 }
 963
 964 GLXContext GLXApiBase::glXCreateContextFn(Display* dpy,
 965                                           XVisualInfo* vis,
 966                                           GLXContext shareList,
 967                                           int direct) {
 968   return driver_->fn.glXCreateContextFn(dpy, vis, shareList, direct);
 969 }
 970
 971 GLXContext GLXApiBase::glXCreateContextAttribsARBFn(Display* dpy,
 972                                                     GLXFBConfig config,
 973                                                     GLXContext share_context,
 974                                                     int direct,
 975                                                     const int* attrib_list) {
 976   return driver_->fn.glXCreateContextAttribsARBFn(dpy, config, share_context,
 977                                                   direct, attrib_list);
 978 }
 979
 980 GLXPixmap GLXApiBase::glXCreateGLXPixmapFn(Display* dpy,
 981                                            XVisualInfo* visual,
 982                                            Pixmap pixmap) {
 983   return driver_->fn.glXCreateGLXPixmapFn(dpy, visual, pixmap);
 984 }
 985
 986 GLXContext GLXApiBase::glXCreateNewContextFn(Display* dpy,
 987                                              GLXFBConfig config,
 988                                              int renderType,
 989                                              GLXContext shareList,
 990                                              int direct) {
 991   return driver_->fn.glXCreateNewContextFn(dpy, config, renderType, shareList,
 992                                            direct);
 993 }
 994
 995 GLXPbuffer GLXApiBase::glXCreatePbufferFn(Display* dpy,
 996                                           GLXFBConfig config,
 997                                           const int* attribList) {
 998   return driver_->fn.glXCreatePbufferFn(dpy, config, attribList);
 999 }
1000
1001 GLXPixmap GLXApiBase::glXCreatePixmapFn(Display* dpy,
1002                                         GLXFBConfig config,
1003                                         Pixmap pixmap,
1004                                         const int* attribList) {
1005   return driver_->fn.glXCreatePixmapFn(dpy, config, pixmap, attribList);
1006 }
1007
1008 GLXWindow GLXApiBase::glXCreateWindowFn(Display* dpy,
1009                                         GLXFBConfig config,
1010                                         Window win,
1011                                         const int* attribList) {
1012   return driver_->fn.glXCreateWindowFn(dpy, config, win, attribList);
1013 }
1014
1015 void GLXApiBase::glXDestroyContextFn(Display* dpy, GLXContext ctx) {
1016   driver_->fn.glXDestroyContextFn(dpy, ctx);
1017 }
1018
1019 void GLXApiBase::glXDestroyGLXPixmapFn(Display* dpy, GLXPixmap pixmap) {
1020   driver_->fn.glXDestroyGLXPixmapFn(dpy, pixmap);
1021 }
1022
1023 void GLXApiBase::glXDestroyPbufferFn(Display* dpy, GLXPbuffer pbuf) {
1024   driver_->fn.glXDestroyPbufferFn(dpy, pbuf);
1025 }
1026
1027 void GLXApiBase::glXDestroyPixmapFn(Display* dpy, GLXPixmap pixmap) {
1028   driver_->fn.glXDestroyPixmapFn(dpy, pixmap);
1029 }
1030
1031 void GLXApiBase::glXDestroyWindowFn(Display* dpy, GLXWindow window) {
1032   driver_->fn.glXDestroyWindowFn(dpy, window);
1033 }
1034
1035 const char* GLXApiBase::glXGetClientStringFn(Display* dpy, int name) {
1036   return driver_->fn.glXGetClientStringFn(dpy, name);
1037 }
1038
1039 int GLXApiBase::glXGetConfigFn(Display* dpy,
1040                                XVisualInfo* visual,
1041                                int attrib,
1042                                int* value) {
1043   return driver_->fn.glXGetConfigFn(dpy, visual, attrib, value);
1044 }
1045
1046 GLXContext GLXApiBase::glXGetCurrentContextFn(void) {
1047   return driver_->fn.glXGetCurrentContextFn();
1048 }
1049
1050 Display* GLXApiBase::glXGetCurrentDisplayFn(void) {
1051   return driver_->fn.glXGetCurrentDisplayFn();
1052 }
1053
1054 GLXDrawable GLXApiBase::glXGetCurrentDrawableFn(void) {
1055   return driver_->fn.glXGetCurrentDrawableFn();
1056 }
1057
1058 GLXDrawable GLXApiBase::glXGetCurrentReadDrawableFn(void) {
1059   return driver_->fn.glXGetCurrentReadDrawableFn();
1060 }
1061
1062 int GLXApiBase::glXGetFBConfigAttribFn(Display* dpy,
1063                                        GLXFBConfig config,
1064                                        int attribute,
1065                                        int* value) {
1066   return driver_->fn.glXGetFBConfigAttribFn(dpy, config, attribute, value);
1067 }
1068
1069 GLXFBConfig GLXApiBase::glXGetFBConfigFromVisualSGIXFn(
1070     Display* dpy,
1071     XVisualInfo* visualInfo) {
1072   return driver_->fn.glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
1073 }
1074
1075 GLXFBConfig* GLXApiBase::glXGetFBConfigsFn(Display* dpy,
1076                                            int screen,
1077                                            int* nelements) {
1078   return driver_->fn.glXGetFBConfigsFn(dpy, screen, nelements);
1079 }
1080
1081 bool GLXApiBase::glXGetMscRateOMLFn(Display* dpy,
1082                                     GLXDrawable drawable,
1083                                     int32* numerator,
1084                                     int32* denominator) {
1085   return driver_->fn.glXGetMscRateOMLFn(dpy, drawable, numerator, denominator);
1086 }
1087
1088 void GLXApiBase::glXGetSelectedEventFn(Display* dpy,
1089                                        GLXDrawable drawable,
1090                                        unsigned long* mask) {
1091   driver_->fn.glXGetSelectedEventFn(dpy, drawable, mask);
1092 }
1093
1094 bool GLXApiBase::glXGetSyncValuesOMLFn(Display* dpy,
1095                                        GLXDrawable drawable,
1096                                        int64* ust,
1097                                        int64* msc,
1098                                        int64* sbc) {
1099   return driver_->fn.glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
1100 }
1101
1102 XVisualInfo* GLXApiBase::glXGetVisualFromFBConfigFn(Display* dpy,
1103                                                     GLXFBConfig config) {
1104   return driver_->fn.glXGetVisualFromFBConfigFn(dpy, config);
1105 }
1106
1107 int GLXApiBase::glXIsDirectFn(Display* dpy, GLXContext ctx) {
1108   return driver_->fn.glXIsDirectFn(dpy, ctx);
1109 }
1110
1111 int GLXApiBase::glXMakeContextCurrentFn(Display* dpy,
1112                                         GLXDrawable draw,
1113                                         GLXDrawable read,
1114                                         GLXContext ctx) {
1115   return driver_->fn.glXMakeContextCurrentFn(dpy, draw, read, ctx);
1116 }
1117
1118 int GLXApiBase::glXMakeCurrentFn(Display* dpy,
1119                                  GLXDrawable drawable,
1120                                  GLXContext ctx) {
1121   return driver_->fn.glXMakeCurrentFn(dpy, drawable, ctx);
1122 }
1123
1124 int GLXApiBase::glXQueryContextFn(Display* dpy,
1125                                   GLXContext ctx,
1126                                   int attribute,
1127                                   int* value) {
1128   return driver_->fn.glXQueryContextFn(dpy, ctx, attribute, value);
1129 }
1130
1131 void GLXApiBase::glXQueryDrawableFn(Display* dpy,
1132                                     GLXDrawable draw,
1133                                     int attribute,
1134                                     unsigned int* value) {
1135   driver_->fn.glXQueryDrawableFn(dpy, draw, attribute, value);
1136 }
1137
1138 int GLXApiBase::glXQueryExtensionFn(Display* dpy, int* errorb, int* event) {
1139   return driver_->fn.glXQueryExtensionFn(dpy, errorb, event);
1140 }
1141
1142 const char* GLXApiBase::glXQueryExtensionsStringFn(Display* dpy, int screen) {
1143   return driver_->fn.glXQueryExtensionsStringFn(dpy, screen);
1144 }
1145
1146 const char* GLXApiBase::glXQueryServerStringFn(Display* dpy,
1147                                                int screen,
1148                                                int name) {
1149   return driver_->fn.glXQueryServerStringFn(dpy, screen, name);
1150 }
1151
1152 int GLXApiBase::glXQueryVersionFn(Display* dpy, int* maj, int* min) {
1153   return driver_->fn.glXQueryVersionFn(dpy, maj, min);
1154 }
1155
1156 void GLXApiBase::glXReleaseTexImageEXTFn(Display* dpy,
1157                                          GLXDrawable drawable,
1158                                          int buffer) {
1159   driver_->fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer);
1160 }
1161
1162 void GLXApiBase::glXSelectEventFn(Display* dpy,
1163                                   GLXDrawable drawable,
1164                                   unsigned long mask) {
1165   driver_->fn.glXSelectEventFn(dpy, drawable, mask);
1166 }
1167
1168 void GLXApiBase::glXSwapBuffersFn(Display* dpy, GLXDrawable drawable) {
1169   driver_->fn.glXSwapBuffersFn(dpy, drawable);
1170 }
1171
1172 void GLXApiBase::glXSwapIntervalEXTFn(Display* dpy,
1173                                       GLXDrawable drawable,
1174                                       int interval) {
1175   driver_->fn.glXSwapIntervalEXTFn(dpy, drawable, interval);
1176 }
1177
1178 void GLXApiBase::glXSwapIntervalMESAFn(unsigned int interval) {
1179   driver_->fn.glXSwapIntervalMESAFn(interval);
1180 }
1181
1182 void GLXApiBase::glXUseXFontFn(Font font, int first, int count, int list) {
1183   driver_->fn.glXUseXFontFn(font, first, count, list);
1184 }
1185
1186 void GLXApiBase::glXWaitGLFn(void) {
1187   driver_->fn.glXWaitGLFn();
1188 }
1189
1190 int GLXApiBase::glXWaitVideoSyncSGIFn(int divisor,
1191                                       int remainder,
1192                                       unsigned int* count) {
1193   return driver_->fn.glXWaitVideoSyncSGIFn(divisor, remainder, count);
1194 }
1195
1196 void GLXApiBase::glXWaitXFn(void) {
1197   driver_->fn.glXWaitXFn();
1198 }
1199
1200 void TraceGLXApi::glXBindTexImageEXTFn(Display* dpy,
1201                                        GLXDrawable drawable,
1202                                        int buffer,
1203                                        int* attribList) {
1204   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXBindTexImageEXT")
1205   glx_api_->glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
1206 }
1207
1208 GLXFBConfig* TraceGLXApi::glXChooseFBConfigFn(Display* dpy,
1209                                               int screen,
1210                                               const int* attribList,
1211                                               int* nitems) {
1212   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXChooseFBConfig")
1213   return glx_api_->glXChooseFBConfigFn(dpy, screen, attribList, nitems);
1214 }
1215
1216 XVisualInfo* TraceGLXApi::glXChooseVisualFn(Display* dpy,
1217                                             int screen,
1218                                             int* attribList) {
1219   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXChooseVisual")
1220   return glx_api_->glXChooseVisualFn(dpy, screen, attribList);
1221 }
1222
1223 void TraceGLXApi::glXCopyContextFn(Display* dpy,
1224                                    GLXContext src,
1225                                    GLXContext dst,
1226                                    unsigned long mask) {
1227   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCopyContext")
1228   glx_api_->glXCopyContextFn(dpy, src, dst, mask);
1229 }
1230
1231 void TraceGLXApi::glXCopySubBufferMESAFn(Display* dpy,
1232                                          GLXDrawable drawable,
1233                                          int x,
1234                                          int y,
1235                                          int width,
1236                                          int height) {
1237   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCopySubBufferMESA")
1238   glx_api_->glXCopySubBufferMESAFn(dpy, drawable, x, y, width, height);
1239 }
1240
1241 GLXContext TraceGLXApi::glXCreateContextFn(Display* dpy,
1242                                            XVisualInfo* vis,
1243                                            GLXContext shareList,
1244                                            int direct) {
1245   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateContext")
1246   return glx_api_->glXCreateContextFn(dpy, vis, shareList, direct);
1247 }
1248
1249 GLXContext TraceGLXApi::glXCreateContextAttribsARBFn(Display* dpy,
1250                                                      GLXFBConfig config,
1251                                                      GLXContext share_context,
1252                                                      int direct,
1253                                                      const int* attrib_list) {
1254   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateContextAttribsARB")
1255   return glx_api_->glXCreateContextAttribsARBFn(dpy, config, share_context,
1256                                                 direct, attrib_list);
1257 }
1258
1259 GLXPixmap TraceGLXApi::glXCreateGLXPixmapFn(Display* dpy,
1260                                             XVisualInfo* visual,
1261                                             Pixmap pixmap) {
1262   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateGLXPixmap")
1263   return glx_api_->glXCreateGLXPixmapFn(dpy, visual, pixmap);
1264 }
1265
1266 GLXContext TraceGLXApi::glXCreateNewContextFn(Display* dpy,
1267                                               GLXFBConfig config,
1268                                               int renderType,
1269                                               GLXContext shareList,
1270                                               int direct) {
1271   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateNewContext")
1272   return glx_api_->glXCreateNewContextFn(dpy, config, renderType, shareList,
1273                                          direct);
1274 }
1275
1276 GLXPbuffer TraceGLXApi::glXCreatePbufferFn(Display* dpy,
1277                                            GLXFBConfig config,
1278                                            const int* attribList) {
1279   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreatePbuffer")
1280   return glx_api_->glXCreatePbufferFn(dpy, config, attribList);
1281 }
1282
1283 GLXPixmap TraceGLXApi::glXCreatePixmapFn(Display* dpy,
1284                                          GLXFBConfig config,
1285                                          Pixmap pixmap,
1286                                          const int* attribList) {
1287   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreatePixmap")
1288   return glx_api_->glXCreatePixmapFn(dpy, config, pixmap, attribList);
1289 }
1290
1291 GLXWindow TraceGLXApi::glXCreateWindowFn(Display* dpy,
1292                                          GLXFBConfig config,
1293                                          Window win,
1294                                          const int* attribList) {
1295   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateWindow")
1296   return glx_api_->glXCreateWindowFn(dpy, config, win, attribList);
1297 }
1298
1299 void TraceGLXApi::glXDestroyContextFn(Display* dpy, GLXContext ctx) {
1300   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyContext")
1301   glx_api_->glXDestroyContextFn(dpy, ctx);
1302 }
1303
1304 void TraceGLXApi::glXDestroyGLXPixmapFn(Display* dpy, GLXPixmap pixmap) {
1305   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyGLXPixmap")
1306   glx_api_->glXDestroyGLXPixmapFn(dpy, pixmap);
1307 }
1308
1309 void TraceGLXApi::glXDestroyPbufferFn(Display* dpy, GLXPbuffer pbuf) {
1310   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyPbuffer")
1311   glx_api_->glXDestroyPbufferFn(dpy, pbuf);
1312 }
1313
1314 void TraceGLXApi::glXDestroyPixmapFn(Display* dpy, GLXPixmap pixmap) {
1315   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyPixmap")
1316   glx_api_->glXDestroyPixmapFn(dpy, pixmap);
1317 }
1318
1319 void TraceGLXApi::glXDestroyWindowFn(Display* dpy, GLXWindow window) {
1320   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyWindow")
1321   glx_api_->glXDestroyWindowFn(dpy, window);
1322 }
1323
1324 const char* TraceGLXApi::glXGetClientStringFn(Display* dpy, int name) {
1325   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetClientString")
1326   return glx_api_->glXGetClientStringFn(dpy, name);
1327 }
1328
1329 int TraceGLXApi::glXGetConfigFn(Display* dpy,
1330                                 XVisualInfo* visual,
1331                                 int attrib,
1332                                 int* value) {
1333   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetConfig")
1334   return glx_api_->glXGetConfigFn(dpy, visual, attrib, value);
1335 }
1336
1337 GLXContext TraceGLXApi::glXGetCurrentContextFn(void) {
1338   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentContext")
1339   return glx_api_->glXGetCurrentContextFn();
1340 }
1341
1342 Display* TraceGLXApi::glXGetCurrentDisplayFn(void) {
1343   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentDisplay")
1344   return glx_api_->glXGetCurrentDisplayFn();
1345 }
1346
1347 GLXDrawable TraceGLXApi::glXGetCurrentDrawableFn(void) {
1348   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentDrawable")
1349   return glx_api_->glXGetCurrentDrawableFn();
1350 }
1351
1352 GLXDrawable TraceGLXApi::glXGetCurrentReadDrawableFn(void) {
1353   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentReadDrawable")
1354   return glx_api_->glXGetCurrentReadDrawableFn();
1355 }
1356
1357 int TraceGLXApi::glXGetFBConfigAttribFn(Display* dpy,
1358                                         GLXFBConfig config,
1359                                         int attribute,
1360                                         int* value) {
1361   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetFBConfigAttrib")
1362   return glx_api_->glXGetFBConfigAttribFn(dpy, config, attribute, value);
1363 }
1364
1365 GLXFBConfig TraceGLXApi::glXGetFBConfigFromVisualSGIXFn(
1366     Display* dpy,
1367     XVisualInfo* visualInfo) {
1368   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1369                                 "TraceGLAPI::glXGetFBConfigFromVisualSGIX")
1370   return glx_api_->glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
1371 }
1372
1373 GLXFBConfig* TraceGLXApi::glXGetFBConfigsFn(Display* dpy,
1374                                             int screen,
1375                                             int* nelements) {
1376   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetFBConfigs")
1377   return glx_api_->glXGetFBConfigsFn(dpy, screen, nelements);
1378 }
1379
1380 bool TraceGLXApi::glXGetMscRateOMLFn(Display* dpy,
1381                                      GLXDrawable drawable,
1382                                      int32* numerator,
1383                                      int32* denominator) {
1384   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetMscRateOML")
1385   return glx_api_->glXGetMscRateOMLFn(dpy, drawable, numerator, denominator);
1386 }
1387
1388 void TraceGLXApi::glXGetSelectedEventFn(Display* dpy,
1389                                         GLXDrawable drawable,
1390                                         unsigned long* mask) {
1391   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetSelectedEvent")
1392   glx_api_->glXGetSelectedEventFn(dpy, drawable, mask);
1393 }
1394
1395 bool TraceGLXApi::glXGetSyncValuesOMLFn(Display* dpy,
1396                                         GLXDrawable drawable,
1397                                         int64* ust,
1398                                         int64* msc,
1399                                         int64* sbc) {
1400   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetSyncValuesOML")
1401   return glx_api_->glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
1402 }
1403
1404 XVisualInfo* TraceGLXApi::glXGetVisualFromFBConfigFn(Display* dpy,
1405                                                      GLXFBConfig config) {
1406   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetVisualFromFBConfig")
1407   return glx_api_->glXGetVisualFromFBConfigFn(dpy, config);
1408 }
1409
1410 int TraceGLXApi::glXIsDirectFn(Display* dpy, GLXContext ctx) {
1411   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXIsDirect")
1412   return glx_api_->glXIsDirectFn(dpy, ctx);
1413 }
1414
1415 int TraceGLXApi::glXMakeContextCurrentFn(Display* dpy,
1416                                          GLXDrawable draw,
1417                                          GLXDrawable read,
1418                                          GLXContext ctx) {
1419   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXMakeContextCurrent")
1420   return glx_api_->glXMakeContextCurrentFn(dpy, draw, read, ctx);
1421 }
1422
1423 int TraceGLXApi::glXMakeCurrentFn(Display* dpy,
1424                                   GLXDrawable drawable,
1425                                   GLXContext ctx) {
1426   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXMakeCurrent")
1427   return glx_api_->glXMakeCurrentFn(dpy, drawable, ctx);
1428 }
1429
1430 int TraceGLXApi::glXQueryContextFn(Display* dpy,
1431                                    GLXContext ctx,
1432                                    int attribute,
1433                                    int* value) {
1434   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryContext")
1435   return glx_api_->glXQueryContextFn(dpy, ctx, attribute, value);
1436 }
1437
1438 void TraceGLXApi::glXQueryDrawableFn(Display* dpy,
1439                                      GLXDrawable draw,
1440                                      int attribute,
1441                                      unsigned int* value) {
1442   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryDrawable")
1443   glx_api_->glXQueryDrawableFn(dpy, draw, attribute, value);
1444 }
1445
1446 int TraceGLXApi::glXQueryExtensionFn(Display* dpy, int* errorb, int* event) {
1447   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryExtension")
1448   return glx_api_->glXQueryExtensionFn(dpy, errorb, event);
1449 }
1450
1451 const char* TraceGLXApi::glXQueryExtensionsStringFn(Display* dpy, int screen) {
1452   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryExtensionsString")
1453   return glx_api_->glXQueryExtensionsStringFn(dpy, screen);
1454 }
1455
1456 const char* TraceGLXApi::glXQueryServerStringFn(Display* dpy,
1457                                                 int screen,
1458                                                 int name) {
1459   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryServerString")
1460   return glx_api_->glXQueryServerStringFn(dpy, screen, name);
1461 }
1462
1463 int TraceGLXApi::glXQueryVersionFn(Display* dpy, int* maj, int* min) {
1464   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryVersion")
1465   return glx_api_->glXQueryVersionFn(dpy, maj, min);
1466 }
1467
1468 void TraceGLXApi::glXReleaseTexImageEXTFn(Display* dpy,
1469                                           GLXDrawable drawable,
1470                                           int buffer) {
1471   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXReleaseTexImageEXT")
1472   glx_api_->glXReleaseTexImageEXTFn(dpy, drawable, buffer);
1473 }
1474
1475 void TraceGLXApi::glXSelectEventFn(Display* dpy,
1476                                    GLXDrawable drawable,
1477                                    unsigned long mask) {
1478   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSelectEvent")
1479   glx_api_->glXSelectEventFn(dpy, drawable, mask);
1480 }
1481
1482 void TraceGLXApi::glXSwapBuffersFn(Display* dpy, GLXDrawable drawable) {
1483   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSwapBuffers")
1484   glx_api_->glXSwapBuffersFn(dpy, drawable);
1485 }
1486
1487 void TraceGLXApi::glXSwapIntervalEXTFn(Display* dpy,
1488                                        GLXDrawable drawable,
1489                                        int interval) {
1490   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSwapIntervalEXT")
1491   glx_api_->glXSwapIntervalEXTFn(dpy, drawable, interval);
1492 }
1493
1494 void TraceGLXApi::glXSwapIntervalMESAFn(unsigned int interval) {
1495   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSwapIntervalMESA")
1496   glx_api_->glXSwapIntervalMESAFn(interval);
1497 }
1498
1499 void TraceGLXApi::glXUseXFontFn(Font font, int first, int count, int list) {
1500   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXUseXFont")
1501   glx_api_->glXUseXFontFn(font, first, count, list);
1502 }
1503
1504 void TraceGLXApi::glXWaitGLFn(void) {
1505   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitGL")
1506   glx_api_->glXWaitGLFn();
1507 }
1508
1509 int TraceGLXApi::glXWaitVideoSyncSGIFn(int divisor,
1510                                        int remainder,
1511                                        unsigned int* count) {
1512   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitVideoSyncSGI")
1513   return glx_api_->glXWaitVideoSyncSGIFn(divisor, remainder, count);
1514 }
1515
1516 void TraceGLXApi::glXWaitXFn(void) {
1517   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitX")
1518   glx_api_->glXWaitXFn();
1519 }
1520
1521 }  // namespace gfx