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 Debug_glXChooseVisual(Display* dpy,
 244                                                           int screen,
 245                                                           int* attribList) {
 246   GL_SERVICE_LOG("glXChooseVisual"
 247                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 248                  << ", " << static_cast<const void*>(attribList) << ")");
 249   XVisualInfo* result =
 250       g_driver_glx.debug_fn.glXChooseVisualFn(dpy, screen, attribList);
 251   GL_SERVICE_LOG("GL_RESULT: " << result);
 252   return result;
 253 }
 254
 255 static void GL_BINDING_CALL Debug_glXCopyContext(Display* dpy,
 256                                                  GLXContext src,
 257                                                  GLXContext dst,
 258                                                  unsigned long mask) {
 259   GL_SERVICE_LOG("glXCopyContext"
 260                  << "(" << static_cast<const void*>(dpy) << ", " << src << ", "
 261                  << dst << ", " << mask << ")");
 262   g_driver_glx.debug_fn.glXCopyContextFn(dpy, src, dst, mask);
 263 }
 264
 265 static void GL_BINDING_CALL Debug_glXCopySubBufferMESA(Display* dpy,
 266                                                        GLXDrawable drawable,
 267                                                        int x,
 268                                                        int y,
 269                                                        int width,
 270                                                        int height) {
 271   GL_SERVICE_LOG("glXCopySubBufferMESA"
 272                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 273                  << ", " << x << ", " << y << ", " << width << ", " << height
 274                  << ")");
 275   g_driver_glx.debug_fn.glXCopySubBufferMESAFn(dpy, drawable, x, y, width,
 276                                                height);
 277 }
 278
 279 static GLXContext GL_BINDING_CALL Debug_glXCreateContext(Display* dpy,
 280                                                          XVisualInfo* vis,
 281                                                          GLXContext shareList,
 282                                                          int direct) {
 283   GL_SERVICE_LOG("glXCreateContext"
 284                  << "(" << static_cast<const void*>(dpy) << ", "
 285                  << static_cast<const void*>(vis) << ", " << shareList << ", "
 286                  << direct << ")");
 287   GLXContext result =
 288       g_driver_glx.debug_fn.glXCreateContextFn(dpy, vis, shareList, direct);
 289   GL_SERVICE_LOG("GL_RESULT: " << result);
 290   return result;
 291 }
 292
 293 static GLXContext GL_BINDING_CALL
 294 Debug_glXCreateContextAttribsARB(Display* dpy,
 295                                  GLXFBConfig config,
 296                                  GLXContext share_context,
 297                                  int direct,
 298                                  const int* attrib_list) {
 299   GL_SERVICE_LOG("glXCreateContextAttribsARB"
 300                  << "(" << static_cast<const void*>(dpy) << ", " << config
 301                  << ", " << share_context << ", " << direct << ", "
 302                  << static_cast<const void*>(attrib_list) << ")");
 303   GLXContext result = g_driver_glx.debug_fn.glXCreateContextAttribsARBFn(
 304       dpy, config, share_context, direct, attrib_list);
 305   GL_SERVICE_LOG("GL_RESULT: " << result);
 306   return result;
 307 }
 308
 309 static GLXPixmap GL_BINDING_CALL Debug_glXCreateGLXPixmap(Display* dpy,
 310                                                           XVisualInfo* visual,
 311                                                           Pixmap pixmap) {
 312   GL_SERVICE_LOG("glXCreateGLXPixmap"
 313                  << "(" << static_cast<const void*>(dpy) << ", "
 314                  << static_cast<const void*>(visual) << ", " << pixmap << ")");
 315   GLXPixmap result =
 316       g_driver_glx.debug_fn.glXCreateGLXPixmapFn(dpy, visual, pixmap);
 317   GL_SERVICE_LOG("GL_RESULT: " << result);
 318   return result;
 319 }
 320
 321 static GLXContext GL_BINDING_CALL
 322 Debug_glXCreateNewContext(Display* dpy,
 323                           GLXFBConfig config,
 324                           int renderType,
 325                           GLXContext shareList,
 326                           int direct) {
 327   GL_SERVICE_LOG("glXCreateNewContext"
 328                  << "(" << static_cast<const void*>(dpy) << ", " << config
 329                  << ", " << renderType << ", " << shareList << ", " << direct
 330                  << ")");
 331   GLXContext result = g_driver_glx.debug_fn.glXCreateNewContextFn(
 332       dpy, config, renderType, shareList, direct);
 333   GL_SERVICE_LOG("GL_RESULT: " << result);
 334   return result;
 335 }
 336
 337 static GLXPbuffer GL_BINDING_CALL
 338 Debug_glXCreatePbuffer(Display* dpy,
 339                        GLXFBConfig config,
 340                        const int* attribList) {
 341   GL_SERVICE_LOG("glXCreatePbuffer"
 342                  << "(" << static_cast<const void*>(dpy) << ", " << config
 343                  << ", " << static_cast<const void*>(attribList) << ")");
 344   GLXPbuffer result =
 345       g_driver_glx.debug_fn.glXCreatePbufferFn(dpy, config, attribList);
 346   GL_SERVICE_LOG("GL_RESULT: " << result);
 347   return result;
 348 }
 349
 350 static GLXPixmap GL_BINDING_CALL Debug_glXCreatePixmap(Display* dpy,
 351                                                        GLXFBConfig config,
 352                                                        Pixmap pixmap,
 353                                                        const int* attribList) {
 354   GL_SERVICE_LOG("glXCreatePixmap"
 355                  << "(" << static_cast<const void*>(dpy) << ", " << config
 356                  << ", " << pixmap << ", "
 357                  << static_cast<const void*>(attribList) << ")");
 358   GLXPixmap result =
 359       g_driver_glx.debug_fn.glXCreatePixmapFn(dpy, config, pixmap, attribList);
 360   GL_SERVICE_LOG("GL_RESULT: " << result);
 361   return result;
 362 }
 363
 364 static GLXWindow GL_BINDING_CALL Debug_glXCreateWindow(Display* dpy,
 365                                                        GLXFBConfig config,
 366                                                        Window win,
 367                                                        const int* attribList) {
 368   GL_SERVICE_LOG("glXCreateWindow"
 369                  << "(" << static_cast<const void*>(dpy) << ", " << config
 370                  << ", " << win << ", " << static_cast<const void*>(attribList)
 371                  << ")");
 372   GLXWindow result =
 373       g_driver_glx.debug_fn.glXCreateWindowFn(dpy, config, win, attribList);
 374   GL_SERVICE_LOG("GL_RESULT: " << result);
 375   return result;
 376 }
 377
 378 static void GL_BINDING_CALL Debug_glXDestroyContext(Display* dpy,
 379                                                     GLXContext ctx) {
 380   GL_SERVICE_LOG("glXDestroyContext"
 381                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
 382   g_driver_glx.debug_fn.glXDestroyContextFn(dpy, ctx);
 383 }
 384
 385 static void GL_BINDING_CALL Debug_glXDestroyGLXPixmap(Display* dpy,
 386                                                       GLXPixmap pixmap) {
 387   GL_SERVICE_LOG("glXDestroyGLXPixmap"
 388                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
 389                  << ")");
 390   g_driver_glx.debug_fn.glXDestroyGLXPixmapFn(dpy, pixmap);
 391 }
 392
 393 static void GL_BINDING_CALL Debug_glXDestroyPbuffer(Display* dpy,
 394                                                     GLXPbuffer pbuf) {
 395   GL_SERVICE_LOG("glXDestroyPbuffer"
 396                  << "(" << static_cast<const void*>(dpy) << ", " << pbuf
 397                  << ")");
 398   g_driver_glx.debug_fn.glXDestroyPbufferFn(dpy, pbuf);
 399 }
 400
 401 static void GL_BINDING_CALL Debug_glXDestroyPixmap(Display* dpy,
 402                                                    GLXPixmap pixmap) {
 403   GL_SERVICE_LOG("glXDestroyPixmap"
 404                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
 405                  << ")");
 406   g_driver_glx.debug_fn.glXDestroyPixmapFn(dpy, pixmap);
 407 }
 408
 409 static void GL_BINDING_CALL Debug_glXDestroyWindow(Display* dpy,
 410                                                    GLXWindow window) {
 411   GL_SERVICE_LOG("glXDestroyWindow"
 412                  << "(" << static_cast<const void*>(dpy) << ", " << window
 413                  << ")");
 414   g_driver_glx.debug_fn.glXDestroyWindowFn(dpy, window);
 415 }
 416
 417 static const char* GL_BINDING_CALL Debug_glXGetClientString(Display* dpy,
 418                                                             int name) {
 419   GL_SERVICE_LOG("glXGetClientString"
 420                  << "(" << static_cast<const void*>(dpy) << ", " << name
 421                  << ")");
 422   const char* result = g_driver_glx.debug_fn.glXGetClientStringFn(dpy, name);
 423   GL_SERVICE_LOG("GL_RESULT: " << result);
 424   return result;
 425 }
 426
 427 static int GL_BINDING_CALL Debug_glXGetConfig(Display* dpy,
 428                                               XVisualInfo* visual,
 429                                               int attrib,
 430                                               int* value) {
 431   GL_SERVICE_LOG("glXGetConfig"
 432                  << "(" << static_cast<const void*>(dpy) << ", "
 433                  << static_cast<const void*>(visual) << ", " << attrib << ", "
 434                  << static_cast<const void*>(value) << ")");
 435   int result = g_driver_glx.debug_fn.glXGetConfigFn(dpy, visual, attrib, value);
 436   GL_SERVICE_LOG("GL_RESULT: " << result);
 437   return result;
 438 }
 439
 440 static GLXContext GL_BINDING_CALL Debug_glXGetCurrentContext(void) {
 441   GL_SERVICE_LOG("glXGetCurrentContext"
 442                  << "("
 443                  << ")");
 444   GLXContext result = g_driver_glx.debug_fn.glXGetCurrentContextFn();
 445   GL_SERVICE_LOG("GL_RESULT: " << result);
 446   return result;
 447 }
 448
 449 static Display* GL_BINDING_CALL Debug_glXGetCurrentDisplay(void) {
 450   GL_SERVICE_LOG("glXGetCurrentDisplay"
 451                  << "("
 452                  << ")");
 453   Display* result = g_driver_glx.debug_fn.glXGetCurrentDisplayFn();
 454   GL_SERVICE_LOG("GL_RESULT: " << result);
 455   return result;
 456 }
 457
 458 static GLXDrawable GL_BINDING_CALL Debug_glXGetCurrentDrawable(void) {
 459   GL_SERVICE_LOG("glXGetCurrentDrawable"
 460                  << "("
 461                  << ")");
 462   GLXDrawable result = g_driver_glx.debug_fn.glXGetCurrentDrawableFn();
 463   GL_SERVICE_LOG("GL_RESULT: " << result);
 464   return result;
 465 }
 466
 467 static GLXDrawable GL_BINDING_CALL Debug_glXGetCurrentReadDrawable(void) {
 468   GL_SERVICE_LOG("glXGetCurrentReadDrawable"
 469                  << "("
 470                  << ")");
 471   GLXDrawable result = g_driver_glx.debug_fn.glXGetCurrentReadDrawableFn();
 472   GL_SERVICE_LOG("GL_RESULT: " << result);
 473   return result;
 474 }
 475
 476 static int GL_BINDING_CALL Debug_glXGetFBConfigAttrib(Display* dpy,
 477                                                       GLXFBConfig config,
 478                                                       int attribute,
 479                                                       int* value) {
 480   GL_SERVICE_LOG("glXGetFBConfigAttrib"
 481                  << "(" << static_cast<const void*>(dpy) << ", " << config
 482                  << ", " << attribute << ", " << static_cast<const void*>(value)
 483                  << ")");
 484   int result = g_driver_glx.debug_fn.glXGetFBConfigAttribFn(dpy, config,
 485                                                             attribute, value);
 486   GL_SERVICE_LOG("GL_RESULT: " << result);
 487   return result;
 488 }
 489
 490 static GLXFBConfig GL_BINDING_CALL
 491 Debug_glXGetFBConfigFromVisualSGIX(Display* dpy, XVisualInfo* visualInfo) {
 492   GL_SERVICE_LOG("glXGetFBConfigFromVisualSGIX"
 493                  << "(" << static_cast<const void*>(dpy) << ", "
 494                  << static_cast<const void*>(visualInfo) << ")");
 495   GLXFBConfig result =
 496       g_driver_glx.debug_fn.glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
 497   GL_SERVICE_LOG("GL_RESULT: " << result);
 498   return result;
 499 }
 500
 501 static GLXFBConfig* GL_BINDING_CALL Debug_glXGetFBConfigs(Display* dpy,
 502                                                           int screen,
 503                                                           int* nelements) {
 504   GL_SERVICE_LOG("glXGetFBConfigs"
 505                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 506                  << ", " << static_cast<const void*>(nelements) << ")");
 507   GLXFBConfig* result =
 508       g_driver_glx.debug_fn.glXGetFBConfigsFn(dpy, screen, nelements);
 509   GL_SERVICE_LOG("GL_RESULT: " << result);
 510   return result;
 511 }
 512
 513 static bool GL_BINDING_CALL Debug_glXGetMscRateOML(Display* dpy,
 514                                                    GLXDrawable drawable,
 515                                                    int32* numerator,
 516                                                    int32* denominator) {
 517   GL_SERVICE_LOG("glXGetMscRateOML"
 518                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 519                  << ", " << static_cast<const void*>(numerator) << ", "
 520                  << static_cast<const void*>(denominator) << ")");
 521   bool result = g_driver_glx.debug_fn.glXGetMscRateOMLFn(
 522       dpy, drawable, numerator, denominator);
 523   GL_SERVICE_LOG("GL_RESULT: " << result);
 524   return result;
 525 }
 526
 527 static void GL_BINDING_CALL Debug_glXGetSelectedEvent(Display* dpy,
 528                                                       GLXDrawable drawable,
 529                                                       unsigned long* mask) {
 530   GL_SERVICE_LOG("glXGetSelectedEvent"
 531                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 532                  << ", " << static_cast<const void*>(mask) << ")");
 533   g_driver_glx.debug_fn.glXGetSelectedEventFn(dpy, drawable, mask);
 534 }
 535
 536 static bool GL_BINDING_CALL Debug_glXGetSyncValuesOML(Display* dpy,
 537                                                       GLXDrawable drawable,
 538                                                       int64* ust,
 539                                                       int64* msc,
 540                                                       int64* sbc) {
 541   GL_SERVICE_LOG("glXGetSyncValuesOML"
 542                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 543                  << ", " << static_cast<const void*>(ust) << ", "
 544                  << static_cast<const void*>(msc) << ", "
 545                  << static_cast<const void*>(sbc) << ")");
 546   bool result =
 547       g_driver_glx.debug_fn.glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
 548   GL_SERVICE_LOG("GL_RESULT: " << result);
 549   return result;
 550 }
 551
 552 static XVisualInfo* GL_BINDING_CALL
 553 Debug_glXGetVisualFromFBConfig(Display* dpy, GLXFBConfig config) {
 554   GL_SERVICE_LOG("glXGetVisualFromFBConfig"
 555                  << "(" << static_cast<const void*>(dpy) << ", " << config
 556                  << ")");
 557   XVisualInfo* result =
 558       g_driver_glx.debug_fn.glXGetVisualFromFBConfigFn(dpy, config);
 559   GL_SERVICE_LOG("GL_RESULT: " << result);
 560   return result;
 561 }
 562
 563 static int GL_BINDING_CALL Debug_glXIsDirect(Display* dpy, GLXContext ctx) {
 564   GL_SERVICE_LOG("glXIsDirect"
 565                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
 566   int result = g_driver_glx.debug_fn.glXIsDirectFn(dpy, ctx);
 567   GL_SERVICE_LOG("GL_RESULT: " << result);
 568   return result;
 569 }
 570
 571 static int GL_BINDING_CALL Debug_glXMakeContextCurrent(Display* dpy,
 572                                                        GLXDrawable draw,
 573                                                        GLXDrawable read,
 574                                                        GLXContext ctx) {
 575   GL_SERVICE_LOG("glXMakeContextCurrent"
 576                  << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
 577                  << read << ", " << ctx << ")");
 578   int result =
 579       g_driver_glx.debug_fn.glXMakeContextCurrentFn(dpy, draw, read, ctx);
 580   GL_SERVICE_LOG("GL_RESULT: " << result);
 581   return result;
 582 }
 583
 584 static int GL_BINDING_CALL Debug_glXMakeCurrent(Display* dpy,
 585                                                 GLXDrawable drawable,
 586                                                 GLXContext ctx) {
 587   GL_SERVICE_LOG("glXMakeCurrent"
 588                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 589                  << ", " << ctx << ")");
 590   int result = g_driver_glx.debug_fn.glXMakeCurrentFn(dpy, drawable, ctx);
 591   GL_SERVICE_LOG("GL_RESULT: " << result);
 592   return result;
 593 }
 594
 595 static int GL_BINDING_CALL Debug_glXQueryContext(Display* dpy,
 596                                                  GLXContext ctx,
 597                                                  int attribute,
 598                                                  int* value) {
 599   GL_SERVICE_LOG("glXQueryContext"
 600                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ", "
 601                  << attribute << ", " << static_cast<const void*>(value)
 602                  << ")");
 603   int result =
 604       g_driver_glx.debug_fn.glXQueryContextFn(dpy, ctx, attribute, value);
 605   GL_SERVICE_LOG("GL_RESULT: " << result);
 606   return result;
 607 }
 608
 609 static void GL_BINDING_CALL Debug_glXQueryDrawable(Display* dpy,
 610                                                    GLXDrawable draw,
 611                                                    int attribute,
 612                                                    unsigned int* value) {
 613   GL_SERVICE_LOG("glXQueryDrawable"
 614                  << "(" << static_cast<const void*>(dpy) << ", " << draw << ", "
 615                  << attribute << ", " << static_cast<const void*>(value)
 616                  << ")");
 617   g_driver_glx.debug_fn.glXQueryDrawableFn(dpy, draw, attribute, value);
 618 }
 619
 620 static int GL_BINDING_CALL Debug_glXQueryExtension(Display* dpy,
 621                                                    int* errorb,
 622                                                    int* event) {
 623   GL_SERVICE_LOG("glXQueryExtension"
 624                  << "(" << static_cast<const void*>(dpy) << ", "
 625                  << static_cast<const void*>(errorb) << ", "
 626                  << static_cast<const void*>(event) << ")");
 627   int result = g_driver_glx.debug_fn.glXQueryExtensionFn(dpy, errorb, event);
 628   GL_SERVICE_LOG("GL_RESULT: " << result);
 629   return result;
 630 }
 631
 632 static const char* GL_BINDING_CALL Debug_glXQueryExtensionsString(Display* dpy,
 633                                                                   int screen) {
 634   GL_SERVICE_LOG("glXQueryExtensionsString"
 635                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 636                  << ")");
 637   const char* result =
 638       g_driver_glx.debug_fn.glXQueryExtensionsStringFn(dpy, screen);
 639   GL_SERVICE_LOG("GL_RESULT: " << result);
 640   return result;
 641 }
 642
 643 static const char* GL_BINDING_CALL Debug_glXQueryServerString(Display* dpy,
 644                                                               int screen,
 645                                                               int name) {
 646   GL_SERVICE_LOG("glXQueryServerString"
 647                  << "(" << static_cast<const void*>(dpy) << ", " << screen
 648                  << ", " << name << ")");
 649   const char* result =
 650       g_driver_glx.debug_fn.glXQueryServerStringFn(dpy, screen, name);
 651   GL_SERVICE_LOG("GL_RESULT: " << result);
 652   return result;
 653 }
 654
 655 static int GL_BINDING_CALL Debug_glXQueryVersion(Display* dpy,
 656                                                  int* maj,
 657                                                  int* min) {
 658   GL_SERVICE_LOG("glXQueryVersion"
 659                  << "(" << static_cast<const void*>(dpy) << ", "
 660                  << static_cast<const void*>(maj) << ", "
 661                  << static_cast<const void*>(min) << ")");
 662   int result = g_driver_glx.debug_fn.glXQueryVersionFn(dpy, maj, min);
 663   GL_SERVICE_LOG("GL_RESULT: " << result);
 664   return result;
 665 }
 666
 667 static void GL_BINDING_CALL Debug_glXReleaseTexImageEXT(Display* dpy,
 668                                                         GLXDrawable drawable,
 669                                                         int buffer) {
 670   GL_SERVICE_LOG("glXReleaseTexImageEXT"
 671                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 672                  << ", " << buffer << ")");
 673   g_driver_glx.debug_fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer);
 674 }
 675
 676 static void GL_BINDING_CALL Debug_glXSelectEvent(Display* dpy,
 677                                                  GLXDrawable drawable,
 678                                                  unsigned long mask) {
 679   GL_SERVICE_LOG("glXSelectEvent"
 680                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 681                  << ", " << mask << ")");
 682   g_driver_glx.debug_fn.glXSelectEventFn(dpy, drawable, mask);
 683 }
 684
 685 static void GL_BINDING_CALL Debug_glXSwapBuffers(Display* dpy,
 686                                                  GLXDrawable drawable) {
 687   GL_SERVICE_LOG("glXSwapBuffers"
 688                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 689                  << ")");
 690   g_driver_glx.debug_fn.glXSwapBuffersFn(dpy, drawable);
 691 }
 692
 693 static void GL_BINDING_CALL Debug_glXSwapIntervalEXT(Display* dpy,
 694                                                      GLXDrawable drawable,
 695                                                      int interval) {
 696   GL_SERVICE_LOG("glXSwapIntervalEXT"
 697                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
 698                  << ", " << interval << ")");
 699   g_driver_glx.debug_fn.glXSwapIntervalEXTFn(dpy, drawable, interval);
 700 }
 701
 702 static void GL_BINDING_CALL Debug_glXSwapIntervalMESA(unsigned int interval) {
 703   GL_SERVICE_LOG("glXSwapIntervalMESA"
 704                  << "(" << interval << ")");
 705   g_driver_glx.debug_fn.glXSwapIntervalMESAFn(interval);
 706 }
 707
 708 static void GL_BINDING_CALL Debug_glXUseXFont(Font font,
 709                                               int first,
 710                                               int count,
 711                                               int list) {
 712   GL_SERVICE_LOG("glXUseXFont"
 713                  << "(" << font << ", " << first << ", " << count << ", "
 714                  << list << ")");
 715   g_driver_glx.debug_fn.glXUseXFontFn(font, first, count, list);
 716 }
 717
 718 static void GL_BINDING_CALL Debug_glXWaitGL(void) {
 719   GL_SERVICE_LOG("glXWaitGL"
 720                  << "("
 721                  << ")");
 722   g_driver_glx.debug_fn.glXWaitGLFn();
 723 }
 724
 725 static int GL_BINDING_CALL Debug_glXWaitVideoSyncSGI(int divisor,
 726                                                      int remainder,
 727                                                      unsigned int* count) {
 728   GL_SERVICE_LOG("glXWaitVideoSyncSGI"
 729                  << "(" << divisor << ", " << remainder << ", "
 730                  << static_cast<const void*>(count) << ")");
 731   int result =
 732       g_driver_glx.debug_fn.glXWaitVideoSyncSGIFn(divisor, remainder, count);
 733   GL_SERVICE_LOG("GL_RESULT: " << result);
 734   return result;
 735 }
 736
 737 static void GL_BINDING_CALL Debug_glXWaitX(void) {
 738   GL_SERVICE_LOG("glXWaitX"
 739                  << "("
 740                  << ")");
 741   g_driver_glx.debug_fn.glXWaitXFn();
 742 }
 743 }  // extern "C"
 744
 745 void DriverGLX::InitializeDebugBindings() {
 746   if (!debug_fn.glXBindTexImageEXTFn) {
 747     debug_fn.glXBindTexImageEXTFn = fn.glXBindTexImageEXTFn;
 748     fn.glXBindTexImageEXTFn = Debug_glXBindTexImageEXT;
 749   }
 750   if (!debug_fn.glXChooseFBConfigFn) {
 751     debug_fn.glXChooseFBConfigFn = fn.glXChooseFBConfigFn;
 752     fn.glXChooseFBConfigFn = Debug_glXChooseFBConfig;
 753   }
 754   if (!debug_fn.glXChooseVisualFn) {
 755     debug_fn.glXChooseVisualFn = fn.glXChooseVisualFn;
 756     fn.glXChooseVisualFn = Debug_glXChooseVisual;
 757   }
 758   if (!debug_fn.glXCopyContextFn) {
 759     debug_fn.glXCopyContextFn = fn.glXCopyContextFn;
 760     fn.glXCopyContextFn = Debug_glXCopyContext;
 761   }
 762   if (!debug_fn.glXCopySubBufferMESAFn) {
 763     debug_fn.glXCopySubBufferMESAFn = fn.glXCopySubBufferMESAFn;
 764     fn.glXCopySubBufferMESAFn = Debug_glXCopySubBufferMESA;
 765   }
 766   if (!debug_fn.glXCreateContextFn) {
 767     debug_fn.glXCreateContextFn = fn.glXCreateContextFn;
 768     fn.glXCreateContextFn = Debug_glXCreateContext;
 769   }
 770   if (!debug_fn.glXCreateContextAttribsARBFn) {
 771     debug_fn.glXCreateContextAttribsARBFn = fn.glXCreateContextAttribsARBFn;
 772     fn.glXCreateContextAttribsARBFn = Debug_glXCreateContextAttribsARB;
 773   }
 774   if (!debug_fn.glXCreateGLXPixmapFn) {
 775     debug_fn.glXCreateGLXPixmapFn = fn.glXCreateGLXPixmapFn;
 776     fn.glXCreateGLXPixmapFn = Debug_glXCreateGLXPixmap;
 777   }
 778   if (!debug_fn.glXCreateNewContextFn) {
 779     debug_fn.glXCreateNewContextFn = fn.glXCreateNewContextFn;
 780     fn.glXCreateNewContextFn = Debug_glXCreateNewContext;
 781   }
 782   if (!debug_fn.glXCreatePbufferFn) {
 783     debug_fn.glXCreatePbufferFn = fn.glXCreatePbufferFn;
 784     fn.glXCreatePbufferFn = Debug_glXCreatePbuffer;
 785   }
 786   if (!debug_fn.glXCreatePixmapFn) {
 787     debug_fn.glXCreatePixmapFn = fn.glXCreatePixmapFn;
 788     fn.glXCreatePixmapFn = Debug_glXCreatePixmap;
 789   }
 790   if (!debug_fn.glXCreateWindowFn) {
 791     debug_fn.glXCreateWindowFn = fn.glXCreateWindowFn;
 792     fn.glXCreateWindowFn = Debug_glXCreateWindow;
 793   }
 794   if (!debug_fn.glXDestroyContextFn) {
 795     debug_fn.glXDestroyContextFn = fn.glXDestroyContextFn;
 796     fn.glXDestroyContextFn = Debug_glXDestroyContext;
 797   }
 798   if (!debug_fn.glXDestroyGLXPixmapFn) {
 799     debug_fn.glXDestroyGLXPixmapFn = fn.glXDestroyGLXPixmapFn;
 800     fn.glXDestroyGLXPixmapFn = Debug_glXDestroyGLXPixmap;
 801   }
 802   if (!debug_fn.glXDestroyPbufferFn) {
 803     debug_fn.glXDestroyPbufferFn = fn.glXDestroyPbufferFn;
 804     fn.glXDestroyPbufferFn = Debug_glXDestroyPbuffer;
 805   }
 806   if (!debug_fn.glXDestroyPixmapFn) {
 807     debug_fn.glXDestroyPixmapFn = fn.glXDestroyPixmapFn;
 808     fn.glXDestroyPixmapFn = Debug_glXDestroyPixmap;
 809   }
 810   if (!debug_fn.glXDestroyWindowFn) {
 811     debug_fn.glXDestroyWindowFn = fn.glXDestroyWindowFn;
 812     fn.glXDestroyWindowFn = Debug_glXDestroyWindow;
 813   }
 814   if (!debug_fn.glXGetClientStringFn) {
 815     debug_fn.glXGetClientStringFn = fn.glXGetClientStringFn;
 816     fn.glXGetClientStringFn = Debug_glXGetClientString;
 817   }
 818   if (!debug_fn.glXGetConfigFn) {
 819     debug_fn.glXGetConfigFn = fn.glXGetConfigFn;
 820     fn.glXGetConfigFn = Debug_glXGetConfig;
 821   }
 822   if (!debug_fn.glXGetCurrentContextFn) {
 823     debug_fn.glXGetCurrentContextFn = fn.glXGetCurrentContextFn;
 824     fn.glXGetCurrentContextFn = Debug_glXGetCurrentContext;
 825   }
 826   if (!debug_fn.glXGetCurrentDisplayFn) {
 827     debug_fn.glXGetCurrentDisplayFn = fn.glXGetCurrentDisplayFn;
 828     fn.glXGetCurrentDisplayFn = Debug_glXGetCurrentDisplay;
 829   }
 830   if (!debug_fn.glXGetCurrentDrawableFn) {
 831     debug_fn.glXGetCurrentDrawableFn = fn.glXGetCurrentDrawableFn;
 832     fn.glXGetCurrentDrawableFn = Debug_glXGetCurrentDrawable;
 833   }
 834   if (!debug_fn.glXGetCurrentReadDrawableFn) {
 835     debug_fn.glXGetCurrentReadDrawableFn = fn.glXGetCurrentReadDrawableFn;
 836     fn.glXGetCurrentReadDrawableFn = Debug_glXGetCurrentReadDrawable;
 837   }
 838   if (!debug_fn.glXGetFBConfigAttribFn) {
 839     debug_fn.glXGetFBConfigAttribFn = fn.glXGetFBConfigAttribFn;
 840     fn.glXGetFBConfigAttribFn = Debug_glXGetFBConfigAttrib;
 841   }
 842   if (!debug_fn.glXGetFBConfigFromVisualSGIXFn) {
 843     debug_fn.glXGetFBConfigFromVisualSGIXFn = fn.glXGetFBConfigFromVisualSGIXFn;
 844     fn.glXGetFBConfigFromVisualSGIXFn = Debug_glXGetFBConfigFromVisualSGIX;
 845   }
 846   if (!debug_fn.glXGetFBConfigsFn) {
 847     debug_fn.glXGetFBConfigsFn = fn.glXGetFBConfigsFn;
 848     fn.glXGetFBConfigsFn = Debug_glXGetFBConfigs;
 849   }
 850   if (!debug_fn.glXGetMscRateOMLFn) {
 851     debug_fn.glXGetMscRateOMLFn = fn.glXGetMscRateOMLFn;
 852     fn.glXGetMscRateOMLFn = Debug_glXGetMscRateOML;
 853   }
 854   if (!debug_fn.glXGetSelectedEventFn) {
 855     debug_fn.glXGetSelectedEventFn = fn.glXGetSelectedEventFn;
 856     fn.glXGetSelectedEventFn = Debug_glXGetSelectedEvent;
 857   }
 858   if (!debug_fn.glXGetSyncValuesOMLFn) {
 859     debug_fn.glXGetSyncValuesOMLFn = fn.glXGetSyncValuesOMLFn;
 860     fn.glXGetSyncValuesOMLFn = Debug_glXGetSyncValuesOML;
 861   }
 862   if (!debug_fn.glXGetVisualFromFBConfigFn) {
 863     debug_fn.glXGetVisualFromFBConfigFn = fn.glXGetVisualFromFBConfigFn;
 864     fn.glXGetVisualFromFBConfigFn = Debug_glXGetVisualFromFBConfig;
 865   }
 866   if (!debug_fn.glXIsDirectFn) {
 867     debug_fn.glXIsDirectFn = fn.glXIsDirectFn;
 868     fn.glXIsDirectFn = Debug_glXIsDirect;
 869   }
 870   if (!debug_fn.glXMakeContextCurrentFn) {
 871     debug_fn.glXMakeContextCurrentFn = fn.glXMakeContextCurrentFn;
 872     fn.glXMakeContextCurrentFn = Debug_glXMakeContextCurrent;
 873   }
 874   if (!debug_fn.glXMakeCurrentFn) {
 875     debug_fn.glXMakeCurrentFn = fn.glXMakeCurrentFn;
 876     fn.glXMakeCurrentFn = Debug_glXMakeCurrent;
 877   }
 878   if (!debug_fn.glXQueryContextFn) {
 879     debug_fn.glXQueryContextFn = fn.glXQueryContextFn;
 880     fn.glXQueryContextFn = Debug_glXQueryContext;
 881   }
 882   if (!debug_fn.glXQueryDrawableFn) {
 883     debug_fn.glXQueryDrawableFn = fn.glXQueryDrawableFn;
 884     fn.glXQueryDrawableFn = Debug_glXQueryDrawable;
 885   }
 886   if (!debug_fn.glXQueryExtensionFn) {
 887     debug_fn.glXQueryExtensionFn = fn.glXQueryExtensionFn;
 888     fn.glXQueryExtensionFn = Debug_glXQueryExtension;
 889   }
 890   if (!debug_fn.glXQueryExtensionsStringFn) {
 891     debug_fn.glXQueryExtensionsStringFn = fn.glXQueryExtensionsStringFn;
 892     fn.glXQueryExtensionsStringFn = Debug_glXQueryExtensionsString;
 893   }
 894   if (!debug_fn.glXQueryServerStringFn) {
 895     debug_fn.glXQueryServerStringFn = fn.glXQueryServerStringFn;
 896     fn.glXQueryServerStringFn = Debug_glXQueryServerString;
 897   }
 898   if (!debug_fn.glXQueryVersionFn) {
 899     debug_fn.glXQueryVersionFn = fn.glXQueryVersionFn;
 900     fn.glXQueryVersionFn = Debug_glXQueryVersion;
 901   }
 902   if (!debug_fn.glXReleaseTexImageEXTFn) {
 903     debug_fn.glXReleaseTexImageEXTFn = fn.glXReleaseTexImageEXTFn;
 904     fn.glXReleaseTexImageEXTFn = Debug_glXReleaseTexImageEXT;
 905   }
 906   if (!debug_fn.glXSelectEventFn) {
 907     debug_fn.glXSelectEventFn = fn.glXSelectEventFn;
 908     fn.glXSelectEventFn = Debug_glXSelectEvent;
 909   }
 910   if (!debug_fn.glXSwapBuffersFn) {
 911     debug_fn.glXSwapBuffersFn = fn.glXSwapBuffersFn;
 912     fn.glXSwapBuffersFn = Debug_glXSwapBuffers;
 913   }
 914   if (!debug_fn.glXSwapIntervalEXTFn) {
 915     debug_fn.glXSwapIntervalEXTFn = fn.glXSwapIntervalEXTFn;
 916     fn.glXSwapIntervalEXTFn = Debug_glXSwapIntervalEXT;
 917   }
 918   if (!debug_fn.glXSwapIntervalMESAFn) {
 919     debug_fn.glXSwapIntervalMESAFn = fn.glXSwapIntervalMESAFn;
 920     fn.glXSwapIntervalMESAFn = Debug_glXSwapIntervalMESA;
 921   }
 922   if (!debug_fn.glXUseXFontFn) {
 923     debug_fn.glXUseXFontFn = fn.glXUseXFontFn;
 924     fn.glXUseXFontFn = Debug_glXUseXFont;
 925   }
 926   if (!debug_fn.glXWaitGLFn) {
 927     debug_fn.glXWaitGLFn = fn.glXWaitGLFn;
 928     fn.glXWaitGLFn = Debug_glXWaitGL;
 929   }
 930   if (!debug_fn.glXWaitVideoSyncSGIFn) {
 931     debug_fn.glXWaitVideoSyncSGIFn = fn.glXWaitVideoSyncSGIFn;
 932     fn.glXWaitVideoSyncSGIFn = Debug_glXWaitVideoSyncSGI;
 933   }
 934   if (!debug_fn.glXWaitXFn) {
 935     debug_fn.glXWaitXFn = fn.glXWaitXFn;
 936     fn.glXWaitXFn = Debug_glXWaitX;
 937   }
 938   g_debugBindingsInitialized = true;
 939 }
 940
 941 void DriverGLX::ClearBindings() {
 942   memset(this, 0, sizeof(*this));
 943 }
 944
 945 void GLXApiBase::glXBindTexImageEXTFn(Display* dpy,
 946                                       GLXDrawable drawable,
 947                                       int buffer,
 948                                       int* attribList) {
 949   driver_->fn.glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
 950 }
 951
 952 GLXFBConfig* GLXApiBase::glXChooseFBConfigFn(Display* dpy,
 953                                              int screen,
 954                                              const int* attribList,
 955                                              int* nitems) {
 956   return driver_->fn.glXChooseFBConfigFn(dpy, screen, attribList, nitems);
 957 }
 958
 959 XVisualInfo* GLXApiBase::glXChooseVisualFn(Display* dpy,
 960                                            int screen,
 961                                            int* attribList) {
 962   return driver_->fn.glXChooseVisualFn(dpy, screen, attribList);
 963 }
 964
 965 void GLXApiBase::glXCopyContextFn(Display* dpy,
 966                                   GLXContext src,
 967                                   GLXContext dst,
 968                                   unsigned long mask) {
 969   driver_->fn.glXCopyContextFn(dpy, src, dst, mask);
 970 }
 971
 972 void GLXApiBase::glXCopySubBufferMESAFn(Display* dpy,
 973                                         GLXDrawable drawable,
 974                                         int x,
 975                                         int y,
 976                                         int width,
 977                                         int height) {
 978   driver_->fn.glXCopySubBufferMESAFn(dpy, drawable, x, y, width, height);
 979 }
 980
 981 GLXContext GLXApiBase::glXCreateContextFn(Display* dpy,
 982                                           XVisualInfo* vis,
 983                                           GLXContext shareList,
 984                                           int direct) {
 985   return driver_->fn.glXCreateContextFn(dpy, vis, shareList, direct);
 986 }
 987
 988 GLXContext GLXApiBase::glXCreateContextAttribsARBFn(Display* dpy,
 989                                                     GLXFBConfig config,
 990                                                     GLXContext share_context,
 991                                                     int direct,
 992                                                     const int* attrib_list) {
 993   return driver_->fn.glXCreateContextAttribsARBFn(dpy, config, share_context,
 994                                                   direct, attrib_list);
 995 }
 996
 997 GLXPixmap GLXApiBase::glXCreateGLXPixmapFn(Display* dpy,
 998                                            XVisualInfo* visual,
 999                                            Pixmap pixmap) {
1000   return driver_->fn.glXCreateGLXPixmapFn(dpy, visual, pixmap);
1001 }
1002
1003 GLXContext GLXApiBase::glXCreateNewContextFn(Display* dpy,
1004                                              GLXFBConfig config,
1005                                              int renderType,
1006                                              GLXContext shareList,
1007                                              int direct) {
1008   return driver_->fn.glXCreateNewContextFn(dpy, config, renderType, shareList,
1009                                            direct);
1010 }
1011
1012 GLXPbuffer GLXApiBase::glXCreatePbufferFn(Display* dpy,
1013                                           GLXFBConfig config,
1014                                           const int* attribList) {
1015   return driver_->fn.glXCreatePbufferFn(dpy, config, attribList);
1016 }
1017
1018 GLXPixmap GLXApiBase::glXCreatePixmapFn(Display* dpy,
1019                                         GLXFBConfig config,
1020                                         Pixmap pixmap,
1021                                         const int* attribList) {
1022   return driver_->fn.glXCreatePixmapFn(dpy, config, pixmap, attribList);
1023 }
1024
1025 GLXWindow GLXApiBase::glXCreateWindowFn(Display* dpy,
1026                                         GLXFBConfig config,
1027                                         Window win,
1028                                         const int* attribList) {
1029   return driver_->fn.glXCreateWindowFn(dpy, config, win, attribList);
1030 }
1031
1032 void GLXApiBase::glXDestroyContextFn(Display* dpy, GLXContext ctx) {
1033   driver_->fn.glXDestroyContextFn(dpy, ctx);
1034 }
1035
1036 void GLXApiBase::glXDestroyGLXPixmapFn(Display* dpy, GLXPixmap pixmap) {
1037   driver_->fn.glXDestroyGLXPixmapFn(dpy, pixmap);
1038 }
1039
1040 void GLXApiBase::glXDestroyPbufferFn(Display* dpy, GLXPbuffer pbuf) {
1041   driver_->fn.glXDestroyPbufferFn(dpy, pbuf);
1042 }
1043
1044 void GLXApiBase::glXDestroyPixmapFn(Display* dpy, GLXPixmap pixmap) {
1045   driver_->fn.glXDestroyPixmapFn(dpy, pixmap);
1046 }
1047
1048 void GLXApiBase::glXDestroyWindowFn(Display* dpy, GLXWindow window) {
1049   driver_->fn.glXDestroyWindowFn(dpy, window);
1050 }
1051
1052 const char* GLXApiBase::glXGetClientStringFn(Display* dpy, int name) {
1053   return driver_->fn.glXGetClientStringFn(dpy, name);
1054 }
1055
1056 int GLXApiBase::glXGetConfigFn(Display* dpy,
1057                                XVisualInfo* visual,
1058                                int attrib,
1059                                int* value) {
1060   return driver_->fn.glXGetConfigFn(dpy, visual, attrib, value);
1061 }
1062
1063 GLXContext GLXApiBase::glXGetCurrentContextFn(void) {
1064   return driver_->fn.glXGetCurrentContextFn();
1065 }
1066
1067 Display* GLXApiBase::glXGetCurrentDisplayFn(void) {
1068   return driver_->fn.glXGetCurrentDisplayFn();
1069 }
1070
1071 GLXDrawable GLXApiBase::glXGetCurrentDrawableFn(void) {
1072   return driver_->fn.glXGetCurrentDrawableFn();
1073 }
1074
1075 GLXDrawable GLXApiBase::glXGetCurrentReadDrawableFn(void) {
1076   return driver_->fn.glXGetCurrentReadDrawableFn();
1077 }
1078
1079 int GLXApiBase::glXGetFBConfigAttribFn(Display* dpy,
1080                                        GLXFBConfig config,
1081                                        int attribute,
1082                                        int* value) {
1083   return driver_->fn.glXGetFBConfigAttribFn(dpy, config, attribute, value);
1084 }
1085
1086 GLXFBConfig GLXApiBase::glXGetFBConfigFromVisualSGIXFn(
1087     Display* dpy,
1088     XVisualInfo* visualInfo) {
1089   return driver_->fn.glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
1090 }
1091
1092 GLXFBConfig* GLXApiBase::glXGetFBConfigsFn(Display* dpy,
1093                                            int screen,
1094                                            int* nelements) {
1095   return driver_->fn.glXGetFBConfigsFn(dpy, screen, nelements);
1096 }
1097
1098 bool GLXApiBase::glXGetMscRateOMLFn(Display* dpy,
1099                                     GLXDrawable drawable,
1100                                     int32* numerator,
1101                                     int32* denominator) {
1102   return driver_->fn.glXGetMscRateOMLFn(dpy, drawable, numerator, denominator);
1103 }
1104
1105 void GLXApiBase::glXGetSelectedEventFn(Display* dpy,
1106                                        GLXDrawable drawable,
1107                                        unsigned long* mask) {
1108   driver_->fn.glXGetSelectedEventFn(dpy, drawable, mask);
1109 }
1110
1111 bool GLXApiBase::glXGetSyncValuesOMLFn(Display* dpy,
1112                                        GLXDrawable drawable,
1113                                        int64* ust,
1114                                        int64* msc,
1115                                        int64* sbc) {
1116   return driver_->fn.glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
1117 }
1118
1119 XVisualInfo* GLXApiBase::glXGetVisualFromFBConfigFn(Display* dpy,
1120                                                     GLXFBConfig config) {
1121   return driver_->fn.glXGetVisualFromFBConfigFn(dpy, config);
1122 }
1123
1124 int GLXApiBase::glXIsDirectFn(Display* dpy, GLXContext ctx) {
1125   return driver_->fn.glXIsDirectFn(dpy, ctx);
1126 }
1127
1128 int GLXApiBase::glXMakeContextCurrentFn(Display* dpy,
1129                                         GLXDrawable draw,
1130                                         GLXDrawable read,
1131                                         GLXContext ctx) {
1132   return driver_->fn.glXMakeContextCurrentFn(dpy, draw, read, ctx);
1133 }
1134
1135 int GLXApiBase::glXMakeCurrentFn(Display* dpy,
1136                                  GLXDrawable drawable,
1137                                  GLXContext ctx) {
1138   return driver_->fn.glXMakeCurrentFn(dpy, drawable, ctx);
1139 }
1140
1141 int GLXApiBase::glXQueryContextFn(Display* dpy,
1142                                   GLXContext ctx,
1143                                   int attribute,
1144                                   int* value) {
1145   return driver_->fn.glXQueryContextFn(dpy, ctx, attribute, value);
1146 }
1147
1148 void GLXApiBase::glXQueryDrawableFn(Display* dpy,
1149                                     GLXDrawable draw,
1150                                     int attribute,
1151                                     unsigned int* value) {
1152   driver_->fn.glXQueryDrawableFn(dpy, draw, attribute, value);
1153 }
1154
1155 int GLXApiBase::glXQueryExtensionFn(Display* dpy, int* errorb, int* event) {
1156   return driver_->fn.glXQueryExtensionFn(dpy, errorb, event);
1157 }
1158
1159 const char* GLXApiBase::glXQueryExtensionsStringFn(Display* dpy, int screen) {
1160   return driver_->fn.glXQueryExtensionsStringFn(dpy, screen);
1161 }
1162
1163 const char* GLXApiBase::glXQueryServerStringFn(Display* dpy,
1164                                                int screen,
1165                                                int name) {
1166   return driver_->fn.glXQueryServerStringFn(dpy, screen, name);
1167 }
1168
1169 int GLXApiBase::glXQueryVersionFn(Display* dpy, int* maj, int* min) {
1170   return driver_->fn.glXQueryVersionFn(dpy, maj, min);
1171 }
1172
1173 void GLXApiBase::glXReleaseTexImageEXTFn(Display* dpy,
1174                                          GLXDrawable drawable,
1175                                          int buffer) {
1176   driver_->fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer);
1177 }
1178
1179 void GLXApiBase::glXSelectEventFn(Display* dpy,
1180                                   GLXDrawable drawable,
1181                                   unsigned long mask) {
1182   driver_->fn.glXSelectEventFn(dpy, drawable, mask);
1183 }
1184
1185 void GLXApiBase::glXSwapBuffersFn(Display* dpy, GLXDrawable drawable) {
1186   driver_->fn.glXSwapBuffersFn(dpy, drawable);
1187 }
1188
1189 void GLXApiBase::glXSwapIntervalEXTFn(Display* dpy,
1190                                       GLXDrawable drawable,
1191                                       int interval) {
1192   driver_->fn.glXSwapIntervalEXTFn(dpy, drawable, interval);
1193 }
1194
1195 void GLXApiBase::glXSwapIntervalMESAFn(unsigned int interval) {
1196   driver_->fn.glXSwapIntervalMESAFn(interval);
1197 }
1198
1199 void GLXApiBase::glXUseXFontFn(Font font, int first, int count, int list) {
1200   driver_->fn.glXUseXFontFn(font, first, count, list);
1201 }
1202
1203 void GLXApiBase::glXWaitGLFn(void) {
1204   driver_->fn.glXWaitGLFn();
1205 }
1206
1207 int GLXApiBase::glXWaitVideoSyncSGIFn(int divisor,
1208                                       int remainder,
1209                                       unsigned int* count) {
1210   return driver_->fn.glXWaitVideoSyncSGIFn(divisor, remainder, count);
1211 }
1212
1213 void GLXApiBase::glXWaitXFn(void) {
1214   driver_->fn.glXWaitXFn();
1215 }
1216
1217 void TraceGLXApi::glXBindTexImageEXTFn(Display* dpy,
1218                                        GLXDrawable drawable,
1219                                        int buffer,
1220                                        int* attribList) {
1221   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXBindTexImageEXT")
1222   glx_api_->glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
1223 }
1224
1225 GLXFBConfig* TraceGLXApi::glXChooseFBConfigFn(Display* dpy,
1226                                               int screen,
1227                                               const int* attribList,
1228                                               int* nitems) {
1229   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXChooseFBConfig")
1230   return glx_api_->glXChooseFBConfigFn(dpy, screen, attribList, nitems);
1231 }
1232
1233 XVisualInfo* TraceGLXApi::glXChooseVisualFn(Display* dpy,
1234                                             int screen,
1235                                             int* attribList) {
1236   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXChooseVisual")
1237   return glx_api_->glXChooseVisualFn(dpy, screen, attribList);
1238 }
1239
1240 void TraceGLXApi::glXCopyContextFn(Display* dpy,
1241                                    GLXContext src,
1242                                    GLXContext dst,
1243                                    unsigned long mask) {
1244   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCopyContext")
1245   glx_api_->glXCopyContextFn(dpy, src, dst, mask);
1246 }
1247
1248 void TraceGLXApi::glXCopySubBufferMESAFn(Display* dpy,
1249                                          GLXDrawable drawable,
1250                                          int x,
1251                                          int y,
1252                                          int width,
1253                                          int height) {
1254   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCopySubBufferMESA")
1255   glx_api_->glXCopySubBufferMESAFn(dpy, drawable, x, y, width, height);
1256 }
1257
1258 GLXContext TraceGLXApi::glXCreateContextFn(Display* dpy,
1259                                            XVisualInfo* vis,
1260                                            GLXContext shareList,
1261                                            int direct) {
1262   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateContext")
1263   return glx_api_->glXCreateContextFn(dpy, vis, shareList, direct);
1264 }
1265
1266 GLXContext TraceGLXApi::glXCreateContextAttribsARBFn(Display* dpy,
1267                                                      GLXFBConfig config,
1268                                                      GLXContext share_context,
1269                                                      int direct,
1270                                                      const int* attrib_list) {
1271   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateContextAttribsARB")
1272   return glx_api_->glXCreateContextAttribsARBFn(dpy, config, share_context,
1273                                                 direct, attrib_list);
1274 }
1275
1276 GLXPixmap TraceGLXApi::glXCreateGLXPixmapFn(Display* dpy,
1277                                             XVisualInfo* visual,
1278                                             Pixmap pixmap) {
1279   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateGLXPixmap")
1280   return glx_api_->glXCreateGLXPixmapFn(dpy, visual, pixmap);
1281 }
1282
1283 GLXContext TraceGLXApi::glXCreateNewContextFn(Display* dpy,
1284                                               GLXFBConfig config,
1285                                               int renderType,
1286                                               GLXContext shareList,
1287                                               int direct) {
1288   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateNewContext")
1289   return glx_api_->glXCreateNewContextFn(dpy, config, renderType, shareList,
1290                                          direct);
1291 }
1292
1293 GLXPbuffer TraceGLXApi::glXCreatePbufferFn(Display* dpy,
1294                                            GLXFBConfig config,
1295                                            const int* attribList) {
1296   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreatePbuffer")
1297   return glx_api_->glXCreatePbufferFn(dpy, config, attribList);
1298 }
1299
1300 GLXPixmap TraceGLXApi::glXCreatePixmapFn(Display* dpy,
1301                                          GLXFBConfig config,
1302                                          Pixmap pixmap,
1303                                          const int* attribList) {
1304   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreatePixmap")
1305   return glx_api_->glXCreatePixmapFn(dpy, config, pixmap, attribList);
1306 }
1307
1308 GLXWindow TraceGLXApi::glXCreateWindowFn(Display* dpy,
1309                                          GLXFBConfig config,
1310                                          Window win,
1311                                          const int* attribList) {
1312   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXCreateWindow")
1313   return glx_api_->glXCreateWindowFn(dpy, config, win, attribList);
1314 }
1315
1316 void TraceGLXApi::glXDestroyContextFn(Display* dpy, GLXContext ctx) {
1317   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyContext")
1318   glx_api_->glXDestroyContextFn(dpy, ctx);
1319 }
1320
1321 void TraceGLXApi::glXDestroyGLXPixmapFn(Display* dpy, GLXPixmap pixmap) {
1322   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyGLXPixmap")
1323   glx_api_->glXDestroyGLXPixmapFn(dpy, pixmap);
1324 }
1325
1326 void TraceGLXApi::glXDestroyPbufferFn(Display* dpy, GLXPbuffer pbuf) {
1327   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyPbuffer")
1328   glx_api_->glXDestroyPbufferFn(dpy, pbuf);
1329 }
1330
1331 void TraceGLXApi::glXDestroyPixmapFn(Display* dpy, GLXPixmap pixmap) {
1332   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyPixmap")
1333   glx_api_->glXDestroyPixmapFn(dpy, pixmap);
1334 }
1335
1336 void TraceGLXApi::glXDestroyWindowFn(Display* dpy, GLXWindow window) {
1337   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyWindow")
1338   glx_api_->glXDestroyWindowFn(dpy, window);
1339 }
1340
1341 const char* TraceGLXApi::glXGetClientStringFn(Display* dpy, int name) {
1342   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetClientString")
1343   return glx_api_->glXGetClientStringFn(dpy, name);
1344 }
1345
1346 int TraceGLXApi::glXGetConfigFn(Display* dpy,
1347                                 XVisualInfo* visual,
1348                                 int attrib,
1349                                 int* value) {
1350   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetConfig")
1351   return glx_api_->glXGetConfigFn(dpy, visual, attrib, value);
1352 }
1353
1354 GLXContext TraceGLXApi::glXGetCurrentContextFn(void) {
1355   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentContext")
1356   return glx_api_->glXGetCurrentContextFn();
1357 }
1358
1359 Display* TraceGLXApi::glXGetCurrentDisplayFn(void) {
1360   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentDisplay")
1361   return glx_api_->glXGetCurrentDisplayFn();
1362 }
1363
1364 GLXDrawable TraceGLXApi::glXGetCurrentDrawableFn(void) {
1365   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentDrawable")
1366   return glx_api_->glXGetCurrentDrawableFn();
1367 }
1368
1369 GLXDrawable TraceGLXApi::glXGetCurrentReadDrawableFn(void) {
1370   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentReadDrawable")
1371   return glx_api_->glXGetCurrentReadDrawableFn();
1372 }
1373
1374 int TraceGLXApi::glXGetFBConfigAttribFn(Display* dpy,
1375                                         GLXFBConfig config,
1376                                         int attribute,
1377                                         int* value) {
1378   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetFBConfigAttrib")
1379   return glx_api_->glXGetFBConfigAttribFn(dpy, config, attribute, value);
1380 }
1381
1382 GLXFBConfig TraceGLXApi::glXGetFBConfigFromVisualSGIXFn(
1383     Display* dpy,
1384     XVisualInfo* visualInfo) {
1385   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1386                                 "TraceGLAPI::glXGetFBConfigFromVisualSGIX")
1387   return glx_api_->glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
1388 }
1389
1390 GLXFBConfig* TraceGLXApi::glXGetFBConfigsFn(Display* dpy,
1391                                             int screen,
1392                                             int* nelements) {
1393   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetFBConfigs")
1394   return glx_api_->glXGetFBConfigsFn(dpy, screen, nelements);
1395 }
1396
1397 bool TraceGLXApi::glXGetMscRateOMLFn(Display* dpy,
1398                                      GLXDrawable drawable,
1399                                      int32* numerator,
1400                                      int32* denominator) {
1401   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetMscRateOML")
1402   return glx_api_->glXGetMscRateOMLFn(dpy, drawable, numerator, denominator);
1403 }
1404
1405 void TraceGLXApi::glXGetSelectedEventFn(Display* dpy,
1406                                         GLXDrawable drawable,
1407                                         unsigned long* mask) {
1408   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetSelectedEvent")
1409   glx_api_->glXGetSelectedEventFn(dpy, drawable, mask);
1410 }
1411
1412 bool TraceGLXApi::glXGetSyncValuesOMLFn(Display* dpy,
1413                                         GLXDrawable drawable,
1414                                         int64* ust,
1415                                         int64* msc,
1416                                         int64* sbc) {
1417   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetSyncValuesOML")
1418   return glx_api_->glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
1419 }
1420
1421 XVisualInfo* TraceGLXApi::glXGetVisualFromFBConfigFn(Display* dpy,
1422                                                      GLXFBConfig config) {
1423   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetVisualFromFBConfig")
1424   return glx_api_->glXGetVisualFromFBConfigFn(dpy, config);
1425 }
1426
1427 int TraceGLXApi::glXIsDirectFn(Display* dpy, GLXContext ctx) {
1428   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXIsDirect")
1429   return glx_api_->glXIsDirectFn(dpy, ctx);
1430 }
1431
1432 int TraceGLXApi::glXMakeContextCurrentFn(Display* dpy,
1433                                          GLXDrawable draw,
1434                                          GLXDrawable read,
1435                                          GLXContext ctx) {
1436   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXMakeContextCurrent")
1437   return glx_api_->glXMakeContextCurrentFn(dpy, draw, read, ctx);
1438 }
1439
1440 int TraceGLXApi::glXMakeCurrentFn(Display* dpy,
1441                                   GLXDrawable drawable,
1442                                   GLXContext ctx) {
1443   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXMakeCurrent")
1444   return glx_api_->glXMakeCurrentFn(dpy, drawable, ctx);
1445 }
1446
1447 int TraceGLXApi::glXQueryContextFn(Display* dpy,
1448                                    GLXContext ctx,
1449                                    int attribute,
1450                                    int* value) {
1451   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryContext")
1452   return glx_api_->glXQueryContextFn(dpy, ctx, attribute, value);
1453 }
1454
1455 void TraceGLXApi::glXQueryDrawableFn(Display* dpy,
1456                                      GLXDrawable draw,
1457                                      int attribute,
1458                                      unsigned int* value) {
1459   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryDrawable")
1460   glx_api_->glXQueryDrawableFn(dpy, draw, attribute, value);
1461 }
1462
1463 int TraceGLXApi::glXQueryExtensionFn(Display* dpy, int* errorb, int* event) {
1464   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryExtension")
1465   return glx_api_->glXQueryExtensionFn(dpy, errorb, event);
1466 }
1467
1468 const char* TraceGLXApi::glXQueryExtensionsStringFn(Display* dpy, int screen) {
1469   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryExtensionsString")
1470   return glx_api_->glXQueryExtensionsStringFn(dpy, screen);
1471 }
1472
1473 const char* TraceGLXApi::glXQueryServerStringFn(Display* dpy,
1474                                                 int screen,
1475                                                 int name) {
1476   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryServerString")
1477   return glx_api_->glXQueryServerStringFn(dpy, screen, name);
1478 }
1479
1480 int TraceGLXApi::glXQueryVersionFn(Display* dpy, int* maj, int* min) {
1481   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryVersion")
1482   return glx_api_->glXQueryVersionFn(dpy, maj, min);
1483 }
1484
1485 void TraceGLXApi::glXReleaseTexImageEXTFn(Display* dpy,
1486                                           GLXDrawable drawable,
1487                                           int buffer) {
1488   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXReleaseTexImageEXT")
1489   glx_api_->glXReleaseTexImageEXTFn(dpy, drawable, buffer);
1490 }
1491
1492 void TraceGLXApi::glXSelectEventFn(Display* dpy,
1493                                    GLXDrawable drawable,
1494                                    unsigned long mask) {
1495   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSelectEvent")
1496   glx_api_->glXSelectEventFn(dpy, drawable, mask);
1497 }
1498
1499 void TraceGLXApi::glXSwapBuffersFn(Display* dpy, GLXDrawable drawable) {
1500   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSwapBuffers")
1501   glx_api_->glXSwapBuffersFn(dpy, drawable);
1502 }
1503
1504 void TraceGLXApi::glXSwapIntervalEXTFn(Display* dpy,
1505                                        GLXDrawable drawable,
1506                                        int interval) {
1507   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSwapIntervalEXT")
1508   glx_api_->glXSwapIntervalEXTFn(dpy, drawable, interval);
1509 }
1510
1511 void TraceGLXApi::glXSwapIntervalMESAFn(unsigned int interval) {
1512   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSwapIntervalMESA")
1513   glx_api_->glXSwapIntervalMESAFn(interval);
1514 }
1515
1516 void TraceGLXApi::glXUseXFontFn(Font font, int first, int count, int list) {
1517   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXUseXFont")
1518   glx_api_->glXUseXFontFn(font, first, count, list);
1519 }
1520
1521 void TraceGLXApi::glXWaitGLFn(void) {
1522   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitGL")
1523   glx_api_->glXWaitGLFn();
1524 }
1525
1526 int TraceGLXApi::glXWaitVideoSyncSGIFn(int divisor,
1527                                        int remainder,
1528                                        unsigned int* count) {
1529   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitVideoSyncSGI")
1530   return glx_api_->glXWaitVideoSyncSGIFn(divisor, remainder, count);
1531 }
1532
1533 void TraceGLXApi::glXWaitXFn(void) {
1534   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitX")
1535   glx_api_->glXWaitXFn();
1536 }
1537
1538 }  // namespace gfx