ui/gl/gl_bindings_autogen_egl.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_egl_api_implementation.h"
  17 #include "ui/gl/gl_enums.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 DriverEGL g_driver_egl;
  25
  26 void DriverEGL::InitializeStaticBindings() {
  27   fn.eglBindAPIFn =
  28       reinterpret_cast<eglBindAPIProc>(GetGLProcAddress("eglBindAPI"));
  29   fn.eglBindTexImageFn = reinterpret_cast<eglBindTexImageProc>(
  30       GetGLProcAddress("eglBindTexImage"));
  31   fn.eglChooseConfigFn = reinterpret_cast<eglChooseConfigProc>(
  32       GetGLProcAddress("eglChooseConfig"));
  33   fn.eglClientWaitSyncKHRFn = reinterpret_cast<eglClientWaitSyncKHRProc>(
  34       GetGLProcAddress("eglClientWaitSyncKHR"));
  35   fn.eglCopyBuffersFn =
  36       reinterpret_cast<eglCopyBuffersProc>(GetGLProcAddress("eglCopyBuffers"));
  37   fn.eglCreateContextFn = reinterpret_cast<eglCreateContextProc>(
  38       GetGLProcAddress("eglCreateContext"));
  39   fn.eglCreateImageKHRFn = 0;
  40   fn.eglCreatePbufferFromClientBufferFn =
  41       reinterpret_cast<eglCreatePbufferFromClientBufferProc>(
  42           GetGLProcAddress("eglCreatePbufferFromClientBuffer"));
  43   fn.eglCreatePbufferSurfaceFn = reinterpret_cast<eglCreatePbufferSurfaceProc>(
  44       GetGLProcAddress("eglCreatePbufferSurface"));
  45   fn.eglCreatePixmapSurfaceFn = reinterpret_cast<eglCreatePixmapSurfaceProc>(
  46       GetGLProcAddress("eglCreatePixmapSurface"));
  47   fn.eglCreateSyncKHRFn = reinterpret_cast<eglCreateSyncKHRProc>(
  48       GetGLProcAddress("eglCreateSyncKHR"));
  49   fn.eglCreateWindowSurfaceFn = reinterpret_cast<eglCreateWindowSurfaceProc>(
  50       GetGLProcAddress("eglCreateWindowSurface"));
  51   fn.eglDestroyContextFn = reinterpret_cast<eglDestroyContextProc>(
  52       GetGLProcAddress("eglDestroyContext"));
  53   fn.eglDestroyImageKHRFn = 0;
  54   fn.eglDestroySurfaceFn = reinterpret_cast<eglDestroySurfaceProc>(
  55       GetGLProcAddress("eglDestroySurface"));
  56   fn.eglDestroySyncKHRFn = reinterpret_cast<eglDestroySyncKHRProc>(
  57       GetGLProcAddress("eglDestroySyncKHR"));
  58   fn.eglGetConfigAttribFn = reinterpret_cast<eglGetConfigAttribProc>(
  59       GetGLProcAddress("eglGetConfigAttrib"));
  60   fn.eglGetConfigsFn =
  61       reinterpret_cast<eglGetConfigsProc>(GetGLProcAddress("eglGetConfigs"));
  62   fn.eglGetCurrentContextFn = reinterpret_cast<eglGetCurrentContextProc>(
  63       GetGLProcAddress("eglGetCurrentContext"));
  64   fn.eglGetCurrentDisplayFn = reinterpret_cast<eglGetCurrentDisplayProc>(
  65       GetGLProcAddress("eglGetCurrentDisplay"));
  66   fn.eglGetCurrentSurfaceFn = reinterpret_cast<eglGetCurrentSurfaceProc>(
  67       GetGLProcAddress("eglGetCurrentSurface"));
  68   fn.eglGetDisplayFn =
  69       reinterpret_cast<eglGetDisplayProc>(GetGLProcAddress("eglGetDisplay"));
  70   fn.eglGetErrorFn =
  71       reinterpret_cast<eglGetErrorProc>(GetGLProcAddress("eglGetError"));
  72   fn.eglGetPlatformDisplayEXTFn = 0;
  73   fn.eglGetProcAddressFn = reinterpret_cast<eglGetProcAddressProc>(
  74       GetGLProcAddress("eglGetProcAddress"));
  75   fn.eglGetSyncAttribKHRFn = reinterpret_cast<eglGetSyncAttribKHRProc>(
  76       GetGLProcAddress("eglGetSyncAttribKHR"));
  77   fn.eglGetSyncValuesCHROMIUMFn = 0;
  78   fn.eglInitializeFn =
  79       reinterpret_cast<eglInitializeProc>(GetGLProcAddress("eglInitialize"));
  80   fn.eglMakeCurrentFn =
  81       reinterpret_cast<eglMakeCurrentProc>(GetGLProcAddress("eglMakeCurrent"));
  82   fn.eglPostSubBufferNVFn = 0;
  83   fn.eglQueryAPIFn =
  84       reinterpret_cast<eglQueryAPIProc>(GetGLProcAddress("eglQueryAPI"));
  85   fn.eglQueryContextFn = reinterpret_cast<eglQueryContextProc>(
  86       GetGLProcAddress("eglQueryContext"));
  87   fn.eglQueryStringFn =
  88       reinterpret_cast<eglQueryStringProc>(GetGLProcAddress("eglQueryString"));
  89   fn.eglQuerySurfaceFn = reinterpret_cast<eglQuerySurfaceProc>(
  90       GetGLProcAddress("eglQuerySurface"));
  91   fn.eglQuerySurfacePointerANGLEFn = 0;
  92   fn.eglReleaseTexImageFn = reinterpret_cast<eglReleaseTexImageProc>(
  93       GetGLProcAddress("eglReleaseTexImage"));
  94   fn.eglReleaseThreadFn = reinterpret_cast<eglReleaseThreadProc>(
  95       GetGLProcAddress("eglReleaseThread"));
  96   fn.eglSurfaceAttribFn = reinterpret_cast<eglSurfaceAttribProc>(
  97       GetGLProcAddress("eglSurfaceAttrib"));
  98   fn.eglSwapBuffersFn =
  99       reinterpret_cast<eglSwapBuffersProc>(GetGLProcAddress("eglSwapBuffers"));
 100   fn.eglSwapIntervalFn = reinterpret_cast<eglSwapIntervalProc>(
 101       GetGLProcAddress("eglSwapInterval"));
 102   fn.eglTerminateFn =
 103       reinterpret_cast<eglTerminateProc>(GetGLProcAddress("eglTerminate"));
 104   fn.eglWaitClientFn =
 105       reinterpret_cast<eglWaitClientProc>(GetGLProcAddress("eglWaitClient"));
 106   fn.eglWaitGLFn =
 107       reinterpret_cast<eglWaitGLProc>(GetGLProcAddress("eglWaitGL"));
 108   fn.eglWaitNativeFn =
 109       reinterpret_cast<eglWaitNativeProc>(GetGLProcAddress("eglWaitNative"));
 110   fn.eglWaitSyncKHRFn = 0;
 111 }
 112
 113 void DriverEGL::InitializeExtensionBindings() {
 114   std::string client_extensions(GetClientExtensions());
 115   client_extensions += " ";
 116   ALLOW_UNUSED_LOCAL(client_extensions);
 117
 118   ext.b_EGL_EXT_platform_base =
 119       client_extensions.find("EGL_EXT_platform_base ") != std::string::npos;
 120
 121   debug_fn.eglGetPlatformDisplayEXTFn = 0;
 122   if (ext.b_EGL_EXT_platform_base) {
 123     fn.eglGetPlatformDisplayEXTFn =
 124         reinterpret_cast<eglGetPlatformDisplayEXTProc>(
 125             GetGLProcAddress("eglGetPlatformDisplayEXT"));
 126     DCHECK(fn.eglGetPlatformDisplayEXTFn);
 127   }
 128   std::string extensions(GetPlatformExtensions());
 129   extensions += " ";
 130   ALLOW_UNUSED_LOCAL(extensions);
 131
 132   ext.b_EGL_ANGLE_d3d_share_handle_client_buffer =
 133       extensions.find("EGL_ANGLE_d3d_share_handle_client_buffer ") !=
 134       std::string::npos;
 135   ext.b_EGL_ANGLE_query_surface_pointer =
 136       extensions.find("EGL_ANGLE_query_surface_pointer ") != std::string::npos;
 137   ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle =
 138       extensions.find("EGL_ANGLE_surface_d3d_texture_2d_share_handle ") !=
 139       std::string::npos;
 140   ext.b_EGL_CHROMIUM_sync_control =
 141       extensions.find("EGL_CHROMIUM_sync_control ") != std::string::npos;
 142   ext.b_EGL_KHR_fence_sync =
 143       extensions.find("EGL_KHR_fence_sync ") != std::string::npos;
 144   ext.b_EGL_KHR_gl_texture_2D_image =
 145       extensions.find("EGL_KHR_gl_texture_2D_image ") != std::string::npos;
 146   ext.b_EGL_KHR_image = extensions.find("EGL_KHR_image ") != std::string::npos;
 147   ext.b_EGL_KHR_image_base =
 148       extensions.find("EGL_KHR_image_base ") != std::string::npos;
 149   ext.b_EGL_KHR_reusable_sync =
 150       extensions.find("EGL_KHR_reusable_sync ") != std::string::npos;
 151   ext.b_EGL_KHR_wait_sync =
 152       extensions.find("EGL_KHR_wait_sync ") != std::string::npos;
 153   ext.b_EGL_NV_post_sub_buffer =
 154       extensions.find("EGL_NV_post_sub_buffer ") != std::string::npos;
 155   ext.b_GL_CHROMIUM_egl_khr_fence_sync_hack =
 156       extensions.find("GL_CHROMIUM_egl_khr_fence_sync_hack ") !=
 157       std::string::npos;
 158
 159   debug_fn.eglCreateImageKHRFn = 0;
 160   if (ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base ||
 161       ext.b_EGL_KHR_gl_texture_2D_image) {
 162     fn.eglCreateImageKHRFn = reinterpret_cast<eglCreateImageKHRProc>(
 163         GetGLProcAddress("eglCreateImageKHR"));
 164     DCHECK(fn.eglCreateImageKHRFn);
 165   }
 166
 167   debug_fn.eglDestroyImageKHRFn = 0;
 168   if (ext.b_EGL_KHR_image || ext.b_EGL_KHR_image_base) {
 169     fn.eglDestroyImageKHRFn = reinterpret_cast<eglDestroyImageKHRProc>(
 170         GetGLProcAddress("eglDestroyImageKHR"));
 171     DCHECK(fn.eglDestroyImageKHRFn);
 172   }
 173
 174   debug_fn.eglGetSyncValuesCHROMIUMFn = 0;
 175   if (ext.b_EGL_CHROMIUM_sync_control) {
 176     fn.eglGetSyncValuesCHROMIUMFn =
 177         reinterpret_cast<eglGetSyncValuesCHROMIUMProc>(
 178             GetGLProcAddress("eglGetSyncValuesCHROMIUM"));
 179     DCHECK(fn.eglGetSyncValuesCHROMIUMFn);
 180   }
 181
 182   debug_fn.eglPostSubBufferNVFn = 0;
 183   if (ext.b_EGL_NV_post_sub_buffer) {
 184     fn.eglPostSubBufferNVFn = reinterpret_cast<eglPostSubBufferNVProc>(
 185         GetGLProcAddress("eglPostSubBufferNV"));
 186     DCHECK(fn.eglPostSubBufferNVFn);
 187   }
 188
 189   debug_fn.eglQuerySurfacePointerANGLEFn = 0;
 190   if (ext.b_EGL_ANGLE_query_surface_pointer) {
 191     fn.eglQuerySurfacePointerANGLEFn =
 192         reinterpret_cast<eglQuerySurfacePointerANGLEProc>(
 193             GetGLProcAddress("eglQuerySurfacePointerANGLE"));
 194     DCHECK(fn.eglQuerySurfacePointerANGLEFn);
 195   }
 196
 197   debug_fn.eglWaitSyncKHRFn = 0;
 198   if (ext.b_EGL_KHR_wait_sync) {
 199     fn.eglWaitSyncKHRFn = reinterpret_cast<eglWaitSyncKHRProc>(
 200         GetGLProcAddress("eglWaitSyncKHR"));
 201     DCHECK(fn.eglWaitSyncKHRFn);
 202   }
 203
 204   if (g_debugBindingsInitialized)
 205     InitializeDebugBindings();
 206 }
 207
 208 extern "C" {
 209
 210 static EGLBoolean GL_BINDING_CALL Debug_eglBindAPI(EGLenum api) {
 211   GL_SERVICE_LOG("eglBindAPI"
 212                  << "(" << api << ")");
 213   EGLBoolean result = g_driver_egl.debug_fn.eglBindAPIFn(api);
 214   GL_SERVICE_LOG("GL_RESULT: " << result);
 215   return result;
 216 }
 217
 218 static EGLBoolean GL_BINDING_CALL Debug_eglBindTexImage(EGLDisplay dpy,
 219                                                         EGLSurface surface,
 220                                                         EGLint buffer) {
 221   GL_SERVICE_LOG("eglBindTexImage"
 222                  << "(" << dpy << ", " << surface << ", " << buffer << ")");
 223   EGLBoolean result =
 224       g_driver_egl.debug_fn.eglBindTexImageFn(dpy, surface, buffer);
 225   GL_SERVICE_LOG("GL_RESULT: " << result);
 226   return result;
 227 }
 228
 229 static EGLBoolean GL_BINDING_CALL
 230 Debug_eglChooseConfig(EGLDisplay dpy,
 231                       const EGLint* attrib_list,
 232                       EGLConfig* configs,
 233                       EGLint config_size,
 234                       EGLint* num_config) {
 235   GL_SERVICE_LOG("eglChooseConfig"
 236                  << "(" << dpy << ", " << static_cast<const void*>(attrib_list)
 237                  << ", " << static_cast<const void*>(configs) << ", "
 238                  << config_size << ", " << static_cast<const void*>(num_config)
 239                  << ")");
 240   EGLBoolean result = g_driver_egl.debug_fn.eglChooseConfigFn(
 241       dpy, attrib_list, configs, config_size, num_config);
 242   GL_SERVICE_LOG("GL_RESULT: " << result);
 243   return result;
 244 }
 245
 246 static EGLint GL_BINDING_CALL Debug_eglClientWaitSyncKHR(EGLDisplay dpy,
 247                                                          EGLSyncKHR sync,
 248                                                          EGLint flags,
 249                                                          EGLTimeKHR timeout) {
 250   GL_SERVICE_LOG("eglClientWaitSyncKHR"
 251                  << "(" << dpy << ", " << sync << ", " << flags << ", "
 252                  << timeout << ")");
 253   EGLint result =
 254       g_driver_egl.debug_fn.eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
 255   GL_SERVICE_LOG("GL_RESULT: " << result);
 256   return result;
 257 }
 258
 259 static EGLBoolean GL_BINDING_CALL
 260 Debug_eglCopyBuffers(EGLDisplay dpy,
 261                      EGLSurface surface,
 262                      EGLNativePixmapType target) {
 263   GL_SERVICE_LOG("eglCopyBuffers"
 264                  << "(" << dpy << ", " << surface << ", " << target << ")");
 265   EGLBoolean result =
 266       g_driver_egl.debug_fn.eglCopyBuffersFn(dpy, surface, target);
 267   GL_SERVICE_LOG("GL_RESULT: " << result);
 268   return result;
 269 }
 270
 271 static EGLContext GL_BINDING_CALL
 272 Debug_eglCreateContext(EGLDisplay dpy,
 273                        EGLConfig config,
 274                        EGLContext share_context,
 275                        const EGLint* attrib_list) {
 276   GL_SERVICE_LOG("eglCreateContext"
 277                  << "(" << dpy << ", " << config << ", " << share_context
 278                  << ", " << static_cast<const void*>(attrib_list) << ")");
 279   EGLContext result = g_driver_egl.debug_fn.eglCreateContextFn(
 280       dpy, config, share_context, attrib_list);
 281   GL_SERVICE_LOG("GL_RESULT: " << result);
 282   return result;
 283 }
 284
 285 static EGLImageKHR GL_BINDING_CALL
 286 Debug_eglCreateImageKHR(EGLDisplay dpy,
 287                         EGLContext ctx,
 288                         EGLenum target,
 289                         EGLClientBuffer buffer,
 290                         const EGLint* attrib_list) {
 291   GL_SERVICE_LOG("eglCreateImageKHR"
 292                  << "(" << dpy << ", " << ctx << ", " << target << ", "
 293                  << buffer << ", " << static_cast<const void*>(attrib_list)
 294                  << ")");
 295   EGLImageKHR result = g_driver_egl.debug_fn.eglCreateImageKHRFn(
 296       dpy, ctx, target, buffer, attrib_list);
 297   GL_SERVICE_LOG("GL_RESULT: " << result);
 298   return result;
 299 }
 300
 301 static EGLSurface GL_BINDING_CALL
 302 Debug_eglCreatePbufferFromClientBuffer(EGLDisplay dpy,
 303                                        EGLenum buftype,
 304                                        void* buffer,
 305                                        EGLConfig config,
 306                                        const EGLint* attrib_list) {
 307   GL_SERVICE_LOG("eglCreatePbufferFromClientBuffer"
 308                  << "(" << dpy << ", " << buftype << ", "
 309                  << static_cast<const void*>(buffer) << ", " << config << ", "
 310                  << static_cast<const void*>(attrib_list) << ")");
 311   EGLSurface result = g_driver_egl.debug_fn.eglCreatePbufferFromClientBufferFn(
 312       dpy, buftype, buffer, config, attrib_list);
 313   GL_SERVICE_LOG("GL_RESULT: " << result);
 314   return result;
 315 }
 316
 317 static EGLSurface GL_BINDING_CALL
 318 Debug_eglCreatePbufferSurface(EGLDisplay dpy,
 319                               EGLConfig config,
 320                               const EGLint* attrib_list) {
 321   GL_SERVICE_LOG("eglCreatePbufferSurface"
 322                  << "(" << dpy << ", " << config << ", "
 323                  << static_cast<const void*>(attrib_list) << ")");
 324   EGLSurface result =
 325       g_driver_egl.debug_fn.eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
 326   GL_SERVICE_LOG("GL_RESULT: " << result);
 327   return result;
 328 }
 329
 330 static EGLSurface GL_BINDING_CALL
 331 Debug_eglCreatePixmapSurface(EGLDisplay dpy,
 332                              EGLConfig config,
 333                              EGLNativePixmapType pixmap,
 334                              const EGLint* attrib_list) {
 335   GL_SERVICE_LOG("eglCreatePixmapSurface"
 336                  << "(" << dpy << ", " << config << ", " << pixmap << ", "
 337                  << static_cast<const void*>(attrib_list) << ")");
 338   EGLSurface result = g_driver_egl.debug_fn.eglCreatePixmapSurfaceFn(
 339       dpy, config, pixmap, attrib_list);
 340   GL_SERVICE_LOG("GL_RESULT: " << result);
 341   return result;
 342 }
 343
 344 static EGLSyncKHR GL_BINDING_CALL
 345 Debug_eglCreateSyncKHR(EGLDisplay dpy,
 346                        EGLenum type,
 347                        const EGLint* attrib_list) {
 348   GL_SERVICE_LOG("eglCreateSyncKHR"
 349                  << "(" << dpy << ", " << type << ", "
 350                  << static_cast<const void*>(attrib_list) << ")");
 351   EGLSyncKHR result =
 352       g_driver_egl.debug_fn.eglCreateSyncKHRFn(dpy, type, attrib_list);
 353   GL_SERVICE_LOG("GL_RESULT: " << result);
 354   return result;
 355 }
 356
 357 static EGLSurface GL_BINDING_CALL
 358 Debug_eglCreateWindowSurface(EGLDisplay dpy,
 359                              EGLConfig config,
 360                              EGLNativeWindowType win,
 361                              const EGLint* attrib_list) {
 362   GL_SERVICE_LOG("eglCreateWindowSurface"
 363                  << "(" << dpy << ", " << config << ", " << win << ", "
 364                  << static_cast<const void*>(attrib_list) << ")");
 365   EGLSurface result = g_driver_egl.debug_fn.eglCreateWindowSurfaceFn(
 366       dpy, config, win, attrib_list);
 367   GL_SERVICE_LOG("GL_RESULT: " << result);
 368   return result;
 369 }
 370
 371 static EGLBoolean GL_BINDING_CALL Debug_eglDestroyContext(EGLDisplay dpy,
 372                                                           EGLContext ctx) {
 373   GL_SERVICE_LOG("eglDestroyContext"
 374                  << "(" << dpy << ", " << ctx << ")");
 375   EGLBoolean result = g_driver_egl.debug_fn.eglDestroyContextFn(dpy, ctx);
 376   GL_SERVICE_LOG("GL_RESULT: " << result);
 377   return result;
 378 }
 379
 380 static EGLBoolean GL_BINDING_CALL Debug_eglDestroyImageKHR(EGLDisplay dpy,
 381                                                            EGLImageKHR image) {
 382   GL_SERVICE_LOG("eglDestroyImageKHR"
 383                  << "(" << dpy << ", " << image << ")");
 384   EGLBoolean result = g_driver_egl.debug_fn.eglDestroyImageKHRFn(dpy, image);
 385   GL_SERVICE_LOG("GL_RESULT: " << result);
 386   return result;
 387 }
 388
 389 static EGLBoolean GL_BINDING_CALL Debug_eglDestroySurface(EGLDisplay dpy,
 390                                                           EGLSurface surface) {
 391   GL_SERVICE_LOG("eglDestroySurface"
 392                  << "(" << dpy << ", " << surface << ")");
 393   EGLBoolean result = g_driver_egl.debug_fn.eglDestroySurfaceFn(dpy, surface);
 394   GL_SERVICE_LOG("GL_RESULT: " << result);
 395   return result;
 396 }
 397
 398 static EGLBoolean GL_BINDING_CALL Debug_eglDestroySyncKHR(EGLDisplay dpy,
 399                                                           EGLSyncKHR sync) {
 400   GL_SERVICE_LOG("eglDestroySyncKHR"
 401                  << "(" << dpy << ", " << sync << ")");
 402   EGLBoolean result = g_driver_egl.debug_fn.eglDestroySyncKHRFn(dpy, sync);
 403   GL_SERVICE_LOG("GL_RESULT: " << result);
 404   return result;
 405 }
 406
 407 static EGLBoolean GL_BINDING_CALL Debug_eglGetConfigAttrib(EGLDisplay dpy,
 408                                                            EGLConfig config,
 409                                                            EGLint attribute,
 410                                                            EGLint* value) {
 411   GL_SERVICE_LOG("eglGetConfigAttrib"
 412                  << "(" << dpy << ", " << config << ", " << attribute << ", "
 413                  << static_cast<const void*>(value) << ")");
 414   EGLBoolean result =
 415       g_driver_egl.debug_fn.eglGetConfigAttribFn(dpy, config, attribute, value);
 416   GL_SERVICE_LOG("GL_RESULT: " << result);
 417   return result;
 418 }
 419
 420 static EGLBoolean GL_BINDING_CALL Debug_eglGetConfigs(EGLDisplay dpy,
 421                                                       EGLConfig* configs,
 422                                                       EGLint config_size,
 423                                                       EGLint* num_config) {
 424   GL_SERVICE_LOG("eglGetConfigs"
 425                  << "(" << dpy << ", " << static_cast<const void*>(configs)
 426                  << ", " << config_size << ", "
 427                  << static_cast<const void*>(num_config) << ")");
 428   EGLBoolean result = g_driver_egl.debug_fn.eglGetConfigsFn(
 429       dpy, configs, config_size, num_config);
 430   GL_SERVICE_LOG("GL_RESULT: " << result);
 431   return result;
 432 }
 433
 434 static EGLContext GL_BINDING_CALL Debug_eglGetCurrentContext(void) {
 435   GL_SERVICE_LOG("eglGetCurrentContext"
 436                  << "("
 437                  << ")");
 438   EGLContext result = g_driver_egl.debug_fn.eglGetCurrentContextFn();
 439   GL_SERVICE_LOG("GL_RESULT: " << result);
 440   return result;
 441 }
 442
 443 static EGLDisplay GL_BINDING_CALL Debug_eglGetCurrentDisplay(void) {
 444   GL_SERVICE_LOG("eglGetCurrentDisplay"
 445                  << "("
 446                  << ")");
 447   EGLDisplay result = g_driver_egl.debug_fn.eglGetCurrentDisplayFn();
 448   GL_SERVICE_LOG("GL_RESULT: " << result);
 449   return result;
 450 }
 451
 452 static EGLSurface GL_BINDING_CALL Debug_eglGetCurrentSurface(EGLint readdraw) {
 453   GL_SERVICE_LOG("eglGetCurrentSurface"
 454                  << "(" << readdraw << ")");
 455   EGLSurface result = g_driver_egl.debug_fn.eglGetCurrentSurfaceFn(readdraw);
 456   GL_SERVICE_LOG("GL_RESULT: " << result);
 457   return result;
 458 }
 459
 460 static EGLDisplay GL_BINDING_CALL
 461 Debug_eglGetDisplay(EGLNativeDisplayType display_id) {
 462   GL_SERVICE_LOG("eglGetDisplay"
 463                  << "(" << display_id << ")");
 464   EGLDisplay result = g_driver_egl.debug_fn.eglGetDisplayFn(display_id);
 465   GL_SERVICE_LOG("GL_RESULT: " << result);
 466   return result;
 467 }
 468
 469 static EGLint GL_BINDING_CALL Debug_eglGetError(void) {
 470   GL_SERVICE_LOG("eglGetError"
 471                  << "("
 472                  << ")");
 473   EGLint result = g_driver_egl.debug_fn.eglGetErrorFn();
 474   GL_SERVICE_LOG("GL_RESULT: " << result);
 475   return result;
 476 }
 477
 478 static EGLDisplay GL_BINDING_CALL
 479 Debug_eglGetPlatformDisplayEXT(EGLenum platform,
 480                                void* native_display,
 481                                const EGLint* attrib_list) {
 482   GL_SERVICE_LOG("eglGetPlatformDisplayEXT"
 483                  << "(" << platform << ", "
 484                  << static_cast<const void*>(native_display) << ", "
 485                  << static_cast<const void*>(attrib_list) << ")");
 486   EGLDisplay result = g_driver_egl.debug_fn.eglGetPlatformDisplayEXTFn(
 487       platform, native_display, attrib_list);
 488   GL_SERVICE_LOG("GL_RESULT: " << result);
 489   return result;
 490 }
 491
 492 static __eglMustCastToProperFunctionPointerType GL_BINDING_CALL
 493 Debug_eglGetProcAddress(const char* procname) {
 494   GL_SERVICE_LOG("eglGetProcAddress"
 495                  << "(" << procname << ")");
 496   __eglMustCastToProperFunctionPointerType result =
 497       g_driver_egl.debug_fn.eglGetProcAddressFn(procname);
 498   GL_SERVICE_LOG("GL_RESULT: " << result);
 499   return result;
 500 }
 501
 502 static EGLBoolean GL_BINDING_CALL Debug_eglGetSyncAttribKHR(EGLDisplay dpy,
 503                                                             EGLSyncKHR sync,
 504                                                             EGLint attribute,
 505                                                             EGLint* value) {
 506   GL_SERVICE_LOG("eglGetSyncAttribKHR"
 507                  << "(" << dpy << ", " << sync << ", " << attribute << ", "
 508                  << static_cast<const void*>(value) << ")");
 509   EGLBoolean result =
 510       g_driver_egl.debug_fn.eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
 511   GL_SERVICE_LOG("GL_RESULT: " << result);
 512   return result;
 513 }
 514
 515 static EGLBoolean GL_BINDING_CALL
 516 Debug_eglGetSyncValuesCHROMIUM(EGLDisplay dpy,
 517                                EGLSurface surface,
 518                                EGLuint64CHROMIUM* ust,
 519                                EGLuint64CHROMIUM* msc,
 520                                EGLuint64CHROMIUM* sbc) {
 521   GL_SERVICE_LOG("eglGetSyncValuesCHROMIUM"
 522                  << "(" << dpy << ", " << surface << ", "
 523                  << static_cast<const void*>(ust) << ", "
 524                  << static_cast<const void*>(msc) << ", "
 525                  << static_cast<const void*>(sbc) << ")");
 526   EGLBoolean result = g_driver_egl.debug_fn.eglGetSyncValuesCHROMIUMFn(
 527       dpy, surface, ust, msc, sbc);
 528   GL_SERVICE_LOG("GL_RESULT: " << result);
 529   return result;
 530 }
 531
 532 static EGLBoolean GL_BINDING_CALL Debug_eglInitialize(EGLDisplay dpy,
 533                                                       EGLint* major,
 534                                                       EGLint* minor) {
 535   GL_SERVICE_LOG("eglInitialize"
 536                  << "(" << dpy << ", " << static_cast<const void*>(major)
 537                  << ", " << static_cast<const void*>(minor) << ")");
 538   EGLBoolean result = g_driver_egl.debug_fn.eglInitializeFn(dpy, major, minor);
 539   GL_SERVICE_LOG("GL_RESULT: " << result);
 540   return result;
 541 }
 542
 543 static EGLBoolean GL_BINDING_CALL Debug_eglMakeCurrent(EGLDisplay dpy,
 544                                                        EGLSurface draw,
 545                                                        EGLSurface read,
 546                                                        EGLContext ctx) {
 547   GL_SERVICE_LOG("eglMakeCurrent"
 548                  << "(" << dpy << ", " << draw << ", " << read << ", " << ctx
 549                  << ")");
 550   EGLBoolean result =
 551       g_driver_egl.debug_fn.eglMakeCurrentFn(dpy, draw, read, ctx);
 552   GL_SERVICE_LOG("GL_RESULT: " << result);
 553   return result;
 554 }
 555
 556 static EGLBoolean GL_BINDING_CALL Debug_eglPostSubBufferNV(EGLDisplay dpy,
 557                                                            EGLSurface surface,
 558                                                            EGLint x,
 559                                                            EGLint y,
 560                                                            EGLint width,
 561                                                            EGLint height) {
 562   GL_SERVICE_LOG("eglPostSubBufferNV"
 563                  << "(" << dpy << ", " << surface << ", " << x << ", " << y
 564                  << ", " << width << ", " << height << ")");
 565   EGLBoolean result = g_driver_egl.debug_fn.eglPostSubBufferNVFn(
 566       dpy, surface, x, y, width, height);
 567   GL_SERVICE_LOG("GL_RESULT: " << result);
 568   return result;
 569 }
 570
 571 static EGLenum GL_BINDING_CALL Debug_eglQueryAPI(void) {
 572   GL_SERVICE_LOG("eglQueryAPI"
 573                  << "("
 574                  << ")");
 575   EGLenum result = g_driver_egl.debug_fn.eglQueryAPIFn();
 576   GL_SERVICE_LOG("GL_RESULT: " << result);
 577   return result;
 578 }
 579
 580 static EGLBoolean GL_BINDING_CALL Debug_eglQueryContext(EGLDisplay dpy,
 581                                                         EGLContext ctx,
 582                                                         EGLint attribute,
 583                                                         EGLint* value) {
 584   GL_SERVICE_LOG("eglQueryContext"
 585                  << "(" << dpy << ", " << ctx << ", " << attribute << ", "
 586                  << static_cast<const void*>(value) << ")");
 587   EGLBoolean result =
 588       g_driver_egl.debug_fn.eglQueryContextFn(dpy, ctx, attribute, value);
 589   GL_SERVICE_LOG("GL_RESULT: " << result);
 590   return result;
 591 }
 592
 593 static const char* GL_BINDING_CALL Debug_eglQueryString(EGLDisplay dpy,
 594                                                         EGLint name) {
 595   GL_SERVICE_LOG("eglQueryString"
 596                  << "(" << dpy << ", " << name << ")");
 597   const char* result = g_driver_egl.debug_fn.eglQueryStringFn(dpy, name);
 598   GL_SERVICE_LOG("GL_RESULT: " << result);
 599   return result;
 600 }
 601
 602 static EGLBoolean GL_BINDING_CALL Debug_eglQuerySurface(EGLDisplay dpy,
 603                                                         EGLSurface surface,
 604                                                         EGLint attribute,
 605                                                         EGLint* value) {
 606   GL_SERVICE_LOG("eglQuerySurface"
 607                  << "(" << dpy << ", " << surface << ", " << attribute << ", "
 608                  << static_cast<const void*>(value) << ")");
 609   EGLBoolean result =
 610       g_driver_egl.debug_fn.eglQuerySurfaceFn(dpy, surface, attribute, value);
 611   GL_SERVICE_LOG("GL_RESULT: " << result);
 612   return result;
 613 }
 614
 615 static EGLBoolean GL_BINDING_CALL
 616 Debug_eglQuerySurfacePointerANGLE(EGLDisplay dpy,
 617                                   EGLSurface surface,
 618                                   EGLint attribute,
 619                                   void** value) {
 620   GL_SERVICE_LOG("eglQuerySurfacePointerANGLE"
 621                  << "(" << dpy << ", " << surface << ", " << attribute << ", "
 622                  << value << ")");
 623   EGLBoolean result = g_driver_egl.debug_fn.eglQuerySurfacePointerANGLEFn(
 624       dpy, surface, attribute, value);
 625   GL_SERVICE_LOG("GL_RESULT: " << result);
 626   return result;
 627 }
 628
 629 static EGLBoolean GL_BINDING_CALL Debug_eglReleaseTexImage(EGLDisplay dpy,
 630                                                            EGLSurface surface,
 631                                                            EGLint buffer) {
 632   GL_SERVICE_LOG("eglReleaseTexImage"
 633                  << "(" << dpy << ", " << surface << ", " << buffer << ")");
 634   EGLBoolean result =
 635       g_driver_egl.debug_fn.eglReleaseTexImageFn(dpy, surface, buffer);
 636   GL_SERVICE_LOG("GL_RESULT: " << result);
 637   return result;
 638 }
 639
 640 static EGLBoolean GL_BINDING_CALL Debug_eglReleaseThread(void) {
 641   GL_SERVICE_LOG("eglReleaseThread"
 642                  << "("
 643                  << ")");
 644   EGLBoolean result = g_driver_egl.debug_fn.eglReleaseThreadFn();
 645   GL_SERVICE_LOG("GL_RESULT: " << result);
 646   return result;
 647 }
 648
 649 static EGLBoolean GL_BINDING_CALL Debug_eglSurfaceAttrib(EGLDisplay dpy,
 650                                                          EGLSurface surface,
 651                                                          EGLint attribute,
 652                                                          EGLint value) {
 653   GL_SERVICE_LOG("eglSurfaceAttrib"
 654                  << "(" << dpy << ", " << surface << ", " << attribute << ", "
 655                  << value << ")");
 656   EGLBoolean result =
 657       g_driver_egl.debug_fn.eglSurfaceAttribFn(dpy, surface, attribute, value);
 658   GL_SERVICE_LOG("GL_RESULT: " << result);
 659   return result;
 660 }
 661
 662 static EGLBoolean GL_BINDING_CALL Debug_eglSwapBuffers(EGLDisplay dpy,
 663                                                        EGLSurface surface) {
 664   GL_SERVICE_LOG("eglSwapBuffers"
 665                  << "(" << dpy << ", " << surface << ")");
 666   EGLBoolean result = g_driver_egl.debug_fn.eglSwapBuffersFn(dpy, surface);
 667   GL_SERVICE_LOG("GL_RESULT: " << result);
 668   return result;
 669 }
 670
 671 static EGLBoolean GL_BINDING_CALL Debug_eglSwapInterval(EGLDisplay dpy,
 672                                                         EGLint interval) {
 673   GL_SERVICE_LOG("eglSwapInterval"
 674                  << "(" << dpy << ", " << interval << ")");
 675   EGLBoolean result = g_driver_egl.debug_fn.eglSwapIntervalFn(dpy, interval);
 676   GL_SERVICE_LOG("GL_RESULT: " << result);
 677   return result;
 678 }
 679
 680 static EGLBoolean GL_BINDING_CALL Debug_eglTerminate(EGLDisplay dpy) {
 681   GL_SERVICE_LOG("eglTerminate"
 682                  << "(" << dpy << ")");
 683   EGLBoolean result = g_driver_egl.debug_fn.eglTerminateFn(dpy);
 684   GL_SERVICE_LOG("GL_RESULT: " << result);
 685   return result;
 686 }
 687
 688 static EGLBoolean GL_BINDING_CALL Debug_eglWaitClient(void) {
 689   GL_SERVICE_LOG("eglWaitClient"
 690                  << "("
 691                  << ")");
 692   EGLBoolean result = g_driver_egl.debug_fn.eglWaitClientFn();
 693   GL_SERVICE_LOG("GL_RESULT: " << result);
 694   return result;
 695 }
 696
 697 static EGLBoolean GL_BINDING_CALL Debug_eglWaitGL(void) {
 698   GL_SERVICE_LOG("eglWaitGL"
 699                  << "("
 700                  << ")");
 701   EGLBoolean result = g_driver_egl.debug_fn.eglWaitGLFn();
 702   GL_SERVICE_LOG("GL_RESULT: " << result);
 703   return result;
 704 }
 705
 706 static EGLBoolean GL_BINDING_CALL Debug_eglWaitNative(EGLint engine) {
 707   GL_SERVICE_LOG("eglWaitNative"
 708                  << "(" << engine << ")");
 709   EGLBoolean result = g_driver_egl.debug_fn.eglWaitNativeFn(engine);
 710   GL_SERVICE_LOG("GL_RESULT: " << result);
 711   return result;
 712 }
 713
 714 static EGLint GL_BINDING_CALL Debug_eglWaitSyncKHR(EGLDisplay dpy,
 715                                                    EGLSyncKHR sync,
 716                                                    EGLint flags) {
 717   GL_SERVICE_LOG("eglWaitSyncKHR"
 718                  << "(" << dpy << ", " << sync << ", " << flags << ")");
 719   EGLint result = g_driver_egl.debug_fn.eglWaitSyncKHRFn(dpy, sync, flags);
 720   GL_SERVICE_LOG("GL_RESULT: " << result);
 721   return result;
 722 }
 723 }  // extern "C"
 724
 725 void DriverEGL::InitializeDebugBindings() {
 726   if (!debug_fn.eglBindAPIFn) {
 727     debug_fn.eglBindAPIFn = fn.eglBindAPIFn;
 728     fn.eglBindAPIFn = Debug_eglBindAPI;
 729   }
 730   if (!debug_fn.eglBindTexImageFn) {
 731     debug_fn.eglBindTexImageFn = fn.eglBindTexImageFn;
 732     fn.eglBindTexImageFn = Debug_eglBindTexImage;
 733   }
 734   if (!debug_fn.eglChooseConfigFn) {
 735     debug_fn.eglChooseConfigFn = fn.eglChooseConfigFn;
 736     fn.eglChooseConfigFn = Debug_eglChooseConfig;
 737   }
 738   if (!debug_fn.eglClientWaitSyncKHRFn) {
 739     debug_fn.eglClientWaitSyncKHRFn = fn.eglClientWaitSyncKHRFn;
 740     fn.eglClientWaitSyncKHRFn = Debug_eglClientWaitSyncKHR;
 741   }
 742   if (!debug_fn.eglCopyBuffersFn) {
 743     debug_fn.eglCopyBuffersFn = fn.eglCopyBuffersFn;
 744     fn.eglCopyBuffersFn = Debug_eglCopyBuffers;
 745   }
 746   if (!debug_fn.eglCreateContextFn) {
 747     debug_fn.eglCreateContextFn = fn.eglCreateContextFn;
 748     fn.eglCreateContextFn = Debug_eglCreateContext;
 749   }
 750   if (!debug_fn.eglCreateImageKHRFn) {
 751     debug_fn.eglCreateImageKHRFn = fn.eglCreateImageKHRFn;
 752     fn.eglCreateImageKHRFn = Debug_eglCreateImageKHR;
 753   }
 754   if (!debug_fn.eglCreatePbufferFromClientBufferFn) {
 755     debug_fn.eglCreatePbufferFromClientBufferFn =
 756         fn.eglCreatePbufferFromClientBufferFn;
 757     fn.eglCreatePbufferFromClientBufferFn =
 758         Debug_eglCreatePbufferFromClientBuffer;
 759   }
 760   if (!debug_fn.eglCreatePbufferSurfaceFn) {
 761     debug_fn.eglCreatePbufferSurfaceFn = fn.eglCreatePbufferSurfaceFn;
 762     fn.eglCreatePbufferSurfaceFn = Debug_eglCreatePbufferSurface;
 763   }
 764   if (!debug_fn.eglCreatePixmapSurfaceFn) {
 765     debug_fn.eglCreatePixmapSurfaceFn = fn.eglCreatePixmapSurfaceFn;
 766     fn.eglCreatePixmapSurfaceFn = Debug_eglCreatePixmapSurface;
 767   }
 768   if (!debug_fn.eglCreateSyncKHRFn) {
 769     debug_fn.eglCreateSyncKHRFn = fn.eglCreateSyncKHRFn;
 770     fn.eglCreateSyncKHRFn = Debug_eglCreateSyncKHR;
 771   }
 772   if (!debug_fn.eglCreateWindowSurfaceFn) {
 773     debug_fn.eglCreateWindowSurfaceFn = fn.eglCreateWindowSurfaceFn;
 774     fn.eglCreateWindowSurfaceFn = Debug_eglCreateWindowSurface;
 775   }
 776   if (!debug_fn.eglDestroyContextFn) {
 777     debug_fn.eglDestroyContextFn = fn.eglDestroyContextFn;
 778     fn.eglDestroyContextFn = Debug_eglDestroyContext;
 779   }
 780   if (!debug_fn.eglDestroyImageKHRFn) {
 781     debug_fn.eglDestroyImageKHRFn = fn.eglDestroyImageKHRFn;
 782     fn.eglDestroyImageKHRFn = Debug_eglDestroyImageKHR;
 783   }
 784   if (!debug_fn.eglDestroySurfaceFn) {
 785     debug_fn.eglDestroySurfaceFn = fn.eglDestroySurfaceFn;
 786     fn.eglDestroySurfaceFn = Debug_eglDestroySurface;
 787   }
 788   if (!debug_fn.eglDestroySyncKHRFn) {
 789     debug_fn.eglDestroySyncKHRFn = fn.eglDestroySyncKHRFn;
 790     fn.eglDestroySyncKHRFn = Debug_eglDestroySyncKHR;
 791   }
 792   if (!debug_fn.eglGetConfigAttribFn) {
 793     debug_fn.eglGetConfigAttribFn = fn.eglGetConfigAttribFn;
 794     fn.eglGetConfigAttribFn = Debug_eglGetConfigAttrib;
 795   }
 796   if (!debug_fn.eglGetConfigsFn) {
 797     debug_fn.eglGetConfigsFn = fn.eglGetConfigsFn;
 798     fn.eglGetConfigsFn = Debug_eglGetConfigs;
 799   }
 800   if (!debug_fn.eglGetCurrentContextFn) {
 801     debug_fn.eglGetCurrentContextFn = fn.eglGetCurrentContextFn;
 802     fn.eglGetCurrentContextFn = Debug_eglGetCurrentContext;
 803   }
 804   if (!debug_fn.eglGetCurrentDisplayFn) {
 805     debug_fn.eglGetCurrentDisplayFn = fn.eglGetCurrentDisplayFn;
 806     fn.eglGetCurrentDisplayFn = Debug_eglGetCurrentDisplay;
 807   }
 808   if (!debug_fn.eglGetCurrentSurfaceFn) {
 809     debug_fn.eglGetCurrentSurfaceFn = fn.eglGetCurrentSurfaceFn;
 810     fn.eglGetCurrentSurfaceFn = Debug_eglGetCurrentSurface;
 811   }
 812   if (!debug_fn.eglGetDisplayFn) {
 813     debug_fn.eglGetDisplayFn = fn.eglGetDisplayFn;
 814     fn.eglGetDisplayFn = Debug_eglGetDisplay;
 815   }
 816   if (!debug_fn.eglGetErrorFn) {
 817     debug_fn.eglGetErrorFn = fn.eglGetErrorFn;
 818     fn.eglGetErrorFn = Debug_eglGetError;
 819   }
 820   if (!debug_fn.eglGetPlatformDisplayEXTFn) {
 821     debug_fn.eglGetPlatformDisplayEXTFn = fn.eglGetPlatformDisplayEXTFn;
 822     fn.eglGetPlatformDisplayEXTFn = Debug_eglGetPlatformDisplayEXT;
 823   }
 824   if (!debug_fn.eglGetProcAddressFn) {
 825     debug_fn.eglGetProcAddressFn = fn.eglGetProcAddressFn;
 826     fn.eglGetProcAddressFn = Debug_eglGetProcAddress;
 827   }
 828   if (!debug_fn.eglGetSyncAttribKHRFn) {
 829     debug_fn.eglGetSyncAttribKHRFn = fn.eglGetSyncAttribKHRFn;
 830     fn.eglGetSyncAttribKHRFn = Debug_eglGetSyncAttribKHR;
 831   }
 832   if (!debug_fn.eglGetSyncValuesCHROMIUMFn) {
 833     debug_fn.eglGetSyncValuesCHROMIUMFn = fn.eglGetSyncValuesCHROMIUMFn;
 834     fn.eglGetSyncValuesCHROMIUMFn = Debug_eglGetSyncValuesCHROMIUM;
 835   }
 836   if (!debug_fn.eglInitializeFn) {
 837     debug_fn.eglInitializeFn = fn.eglInitializeFn;
 838     fn.eglInitializeFn = Debug_eglInitialize;
 839   }
 840   if (!debug_fn.eglMakeCurrentFn) {
 841     debug_fn.eglMakeCurrentFn = fn.eglMakeCurrentFn;
 842     fn.eglMakeCurrentFn = Debug_eglMakeCurrent;
 843   }
 844   if (!debug_fn.eglPostSubBufferNVFn) {
 845     debug_fn.eglPostSubBufferNVFn = fn.eglPostSubBufferNVFn;
 846     fn.eglPostSubBufferNVFn = Debug_eglPostSubBufferNV;
 847   }
 848   if (!debug_fn.eglQueryAPIFn) {
 849     debug_fn.eglQueryAPIFn = fn.eglQueryAPIFn;
 850     fn.eglQueryAPIFn = Debug_eglQueryAPI;
 851   }
 852   if (!debug_fn.eglQueryContextFn) {
 853     debug_fn.eglQueryContextFn = fn.eglQueryContextFn;
 854     fn.eglQueryContextFn = Debug_eglQueryContext;
 855   }
 856   if (!debug_fn.eglQueryStringFn) {
 857     debug_fn.eglQueryStringFn = fn.eglQueryStringFn;
 858     fn.eglQueryStringFn = Debug_eglQueryString;
 859   }
 860   if (!debug_fn.eglQuerySurfaceFn) {
 861     debug_fn.eglQuerySurfaceFn = fn.eglQuerySurfaceFn;
 862     fn.eglQuerySurfaceFn = Debug_eglQuerySurface;
 863   }
 864   if (!debug_fn.eglQuerySurfacePointerANGLEFn) {
 865     debug_fn.eglQuerySurfacePointerANGLEFn = fn.eglQuerySurfacePointerANGLEFn;
 866     fn.eglQuerySurfacePointerANGLEFn = Debug_eglQuerySurfacePointerANGLE;
 867   }
 868   if (!debug_fn.eglReleaseTexImageFn) {
 869     debug_fn.eglReleaseTexImageFn = fn.eglReleaseTexImageFn;
 870     fn.eglReleaseTexImageFn = Debug_eglReleaseTexImage;
 871   }
 872   if (!debug_fn.eglReleaseThreadFn) {
 873     debug_fn.eglReleaseThreadFn = fn.eglReleaseThreadFn;
 874     fn.eglReleaseThreadFn = Debug_eglReleaseThread;
 875   }
 876   if (!debug_fn.eglSurfaceAttribFn) {
 877     debug_fn.eglSurfaceAttribFn = fn.eglSurfaceAttribFn;
 878     fn.eglSurfaceAttribFn = Debug_eglSurfaceAttrib;
 879   }
 880   if (!debug_fn.eglSwapBuffersFn) {
 881     debug_fn.eglSwapBuffersFn = fn.eglSwapBuffersFn;
 882     fn.eglSwapBuffersFn = Debug_eglSwapBuffers;
 883   }
 884   if (!debug_fn.eglSwapIntervalFn) {
 885     debug_fn.eglSwapIntervalFn = fn.eglSwapIntervalFn;
 886     fn.eglSwapIntervalFn = Debug_eglSwapInterval;
 887   }
 888   if (!debug_fn.eglTerminateFn) {
 889     debug_fn.eglTerminateFn = fn.eglTerminateFn;
 890     fn.eglTerminateFn = Debug_eglTerminate;
 891   }
 892   if (!debug_fn.eglWaitClientFn) {
 893     debug_fn.eglWaitClientFn = fn.eglWaitClientFn;
 894     fn.eglWaitClientFn = Debug_eglWaitClient;
 895   }
 896   if (!debug_fn.eglWaitGLFn) {
 897     debug_fn.eglWaitGLFn = fn.eglWaitGLFn;
 898     fn.eglWaitGLFn = Debug_eglWaitGL;
 899   }
 900   if (!debug_fn.eglWaitNativeFn) {
 901     debug_fn.eglWaitNativeFn = fn.eglWaitNativeFn;
 902     fn.eglWaitNativeFn = Debug_eglWaitNative;
 903   }
 904   if (!debug_fn.eglWaitSyncKHRFn) {
 905     debug_fn.eglWaitSyncKHRFn = fn.eglWaitSyncKHRFn;
 906     fn.eglWaitSyncKHRFn = Debug_eglWaitSyncKHR;
 907   }
 908   g_debugBindingsInitialized = true;
 909 }
 910
 911 void DriverEGL::ClearBindings() {
 912   memset(this, 0, sizeof(*this));
 913 }
 914
 915 EGLBoolean EGLApiBase::eglBindAPIFn(EGLenum api) {
 916   return driver_->fn.eglBindAPIFn(api);
 917 }
 918
 919 EGLBoolean EGLApiBase::eglBindTexImageFn(EGLDisplay dpy,
 920                                          EGLSurface surface,
 921                                          EGLint buffer) {
 922   return driver_->fn.eglBindTexImageFn(dpy, surface, buffer);
 923 }
 924
 925 EGLBoolean EGLApiBase::eglChooseConfigFn(EGLDisplay dpy,
 926                                          const EGLint* attrib_list,
 927                                          EGLConfig* configs,
 928                                          EGLint config_size,
 929                                          EGLint* num_config) {
 930   return driver_->fn.eglChooseConfigFn(dpy, attrib_list, configs, config_size,
 931                                        num_config);
 932 }
 933
 934 EGLint EGLApiBase::eglClientWaitSyncKHRFn(EGLDisplay dpy,
 935                                           EGLSyncKHR sync,
 936                                           EGLint flags,
 937                                           EGLTimeKHR timeout) {
 938   return driver_->fn.eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
 939 }
 940
 941 EGLBoolean EGLApiBase::eglCopyBuffersFn(EGLDisplay dpy,
 942                                         EGLSurface surface,
 943                                         EGLNativePixmapType target) {
 944   return driver_->fn.eglCopyBuffersFn(dpy, surface, target);
 945 }
 946
 947 EGLContext EGLApiBase::eglCreateContextFn(EGLDisplay dpy,
 948                                           EGLConfig config,
 949                                           EGLContext share_context,
 950                                           const EGLint* attrib_list) {
 951   return driver_->fn.eglCreateContextFn(dpy, config, share_context,
 952                                         attrib_list);
 953 }
 954
 955 EGLImageKHR EGLApiBase::eglCreateImageKHRFn(EGLDisplay dpy,
 956                                             EGLContext ctx,
 957                                             EGLenum target,
 958                                             EGLClientBuffer buffer,
 959                                             const EGLint* attrib_list) {
 960   return driver_->fn.eglCreateImageKHRFn(dpy, ctx, target, buffer, attrib_list);
 961 }
 962
 963 EGLSurface EGLApiBase::eglCreatePbufferFromClientBufferFn(
 964     EGLDisplay dpy,
 965     EGLenum buftype,
 966     void* buffer,
 967     EGLConfig config,
 968     const EGLint* attrib_list) {
 969   return driver_->fn.eglCreatePbufferFromClientBufferFn(dpy, buftype, buffer,
 970                                                         config, attrib_list);
 971 }
 972
 973 EGLSurface EGLApiBase::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
 974                                                  EGLConfig config,
 975                                                  const EGLint* attrib_list) {
 976   return driver_->fn.eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
 977 }
 978
 979 EGLSurface EGLApiBase::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
 980                                                 EGLConfig config,
 981                                                 EGLNativePixmapType pixmap,
 982                                                 const EGLint* attrib_list) {
 983   return driver_->fn.eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
 984 }
 985
 986 EGLSyncKHR EGLApiBase::eglCreateSyncKHRFn(EGLDisplay dpy,
 987                                           EGLenum type,
 988                                           const EGLint* attrib_list) {
 989   return driver_->fn.eglCreateSyncKHRFn(dpy, type, attrib_list);
 990 }
 991
 992 EGLSurface EGLApiBase::eglCreateWindowSurfaceFn(EGLDisplay dpy,
 993                                                 EGLConfig config,
 994                                                 EGLNativeWindowType win,
 995                                                 const EGLint* attrib_list) {
 996   return driver_->fn.eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
 997 }
 998
 999 EGLBoolean EGLApiBase::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
1000   return driver_->fn.eglDestroyContextFn(dpy, ctx);
1001 }
1002
1003 EGLBoolean EGLApiBase::eglDestroyImageKHRFn(EGLDisplay dpy, EGLImageKHR image) {
1004   return driver_->fn.eglDestroyImageKHRFn(dpy, image);
1005 }
1006
1007 EGLBoolean EGLApiBase::eglDestroySurfaceFn(EGLDisplay dpy, EGLSurface surface) {
1008   return driver_->fn.eglDestroySurfaceFn(dpy, surface);
1009 }
1010
1011 EGLBoolean EGLApiBase::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
1012   return driver_->fn.eglDestroySyncKHRFn(dpy, sync);
1013 }
1014
1015 EGLBoolean EGLApiBase::eglGetConfigAttribFn(EGLDisplay dpy,
1016                                             EGLConfig config,
1017                                             EGLint attribute,
1018                                             EGLint* value) {
1019   return driver_->fn.eglGetConfigAttribFn(dpy, config, attribute, value);
1020 }
1021
1022 EGLBoolean EGLApiBase::eglGetConfigsFn(EGLDisplay dpy,
1023                                        EGLConfig* configs,
1024                                        EGLint config_size,
1025                                        EGLint* num_config) {
1026   return driver_->fn.eglGetConfigsFn(dpy, configs, config_size, num_config);
1027 }
1028
1029 EGLContext EGLApiBase::eglGetCurrentContextFn(void) {
1030   return driver_->fn.eglGetCurrentContextFn();
1031 }
1032
1033 EGLDisplay EGLApiBase::eglGetCurrentDisplayFn(void) {
1034   return driver_->fn.eglGetCurrentDisplayFn();
1035 }
1036
1037 EGLSurface EGLApiBase::eglGetCurrentSurfaceFn(EGLint readdraw) {
1038   return driver_->fn.eglGetCurrentSurfaceFn(readdraw);
1039 }
1040
1041 EGLDisplay EGLApiBase::eglGetDisplayFn(EGLNativeDisplayType display_id) {
1042   return driver_->fn.eglGetDisplayFn(display_id);
1043 }
1044
1045 EGLint EGLApiBase::eglGetErrorFn(void) {
1046   return driver_->fn.eglGetErrorFn();
1047 }
1048
1049 EGLDisplay EGLApiBase::eglGetPlatformDisplayEXTFn(EGLenum platform,
1050                                                   void* native_display,
1051                                                   const EGLint* attrib_list) {
1052   return driver_->fn.eglGetPlatformDisplayEXTFn(platform, native_display,
1053                                                 attrib_list);
1054 }
1055
1056 __eglMustCastToProperFunctionPointerType EGLApiBase::eglGetProcAddressFn(
1057     const char* procname) {
1058   return driver_->fn.eglGetProcAddressFn(procname);
1059 }
1060
1061 EGLBoolean EGLApiBase::eglGetSyncAttribKHRFn(EGLDisplay dpy,
1062                                              EGLSyncKHR sync,
1063                                              EGLint attribute,
1064                                              EGLint* value) {
1065   return driver_->fn.eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
1066 }
1067
1068 EGLBoolean EGLApiBase::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
1069                                                   EGLSurface surface,
1070                                                   EGLuint64CHROMIUM* ust,
1071                                                   EGLuint64CHROMIUM* msc,
1072                                                   EGLuint64CHROMIUM* sbc) {
1073   return driver_->fn.eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc);
1074 }
1075
1076 EGLBoolean EGLApiBase::eglInitializeFn(EGLDisplay dpy,
1077                                        EGLint* major,
1078                                        EGLint* minor) {
1079   return driver_->fn.eglInitializeFn(dpy, major, minor);
1080 }
1081
1082 EGLBoolean EGLApiBase::eglMakeCurrentFn(EGLDisplay dpy,
1083                                         EGLSurface draw,
1084                                         EGLSurface read,
1085                                         EGLContext ctx) {
1086   return driver_->fn.eglMakeCurrentFn(dpy, draw, read, ctx);
1087 }
1088
1089 EGLBoolean EGLApiBase::eglPostSubBufferNVFn(EGLDisplay dpy,
1090                                             EGLSurface surface,
1091                                             EGLint x,
1092                                             EGLint y,
1093                                             EGLint width,
1094                                             EGLint height) {
1095   return driver_->fn.eglPostSubBufferNVFn(dpy, surface, x, y, width, height);
1096 }
1097
1098 EGLenum EGLApiBase::eglQueryAPIFn(void) {
1099   return driver_->fn.eglQueryAPIFn();
1100 }
1101
1102 EGLBoolean EGLApiBase::eglQueryContextFn(EGLDisplay dpy,
1103                                          EGLContext ctx,
1104                                          EGLint attribute,
1105                                          EGLint* value) {
1106   return driver_->fn.eglQueryContextFn(dpy, ctx, attribute, value);
1107 }
1108
1109 const char* EGLApiBase::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
1110   return driver_->fn.eglQueryStringFn(dpy, name);
1111 }
1112
1113 EGLBoolean EGLApiBase::eglQuerySurfaceFn(EGLDisplay dpy,
1114                                          EGLSurface surface,
1115                                          EGLint attribute,
1116                                          EGLint* value) {
1117   return driver_->fn.eglQuerySurfaceFn(dpy, surface, attribute, value);
1118 }
1119
1120 EGLBoolean EGLApiBase::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
1121                                                      EGLSurface surface,
1122                                                      EGLint attribute,
1123                                                      void** value) {
1124   return driver_->fn.eglQuerySurfacePointerANGLEFn(dpy, surface, attribute,
1125                                                    value);
1126 }
1127
1128 EGLBoolean EGLApiBase::eglReleaseTexImageFn(EGLDisplay dpy,
1129                                             EGLSurface surface,
1130                                             EGLint buffer) {
1131   return driver_->fn.eglReleaseTexImageFn(dpy, surface, buffer);
1132 }
1133
1134 EGLBoolean EGLApiBase::eglReleaseThreadFn(void) {
1135   return driver_->fn.eglReleaseThreadFn();
1136 }
1137
1138 EGLBoolean EGLApiBase::eglSurfaceAttribFn(EGLDisplay dpy,
1139                                           EGLSurface surface,
1140                                           EGLint attribute,
1141                                           EGLint value) {
1142   return driver_->fn.eglSurfaceAttribFn(dpy, surface, attribute, value);
1143 }
1144
1145 EGLBoolean EGLApiBase::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
1146   return driver_->fn.eglSwapBuffersFn(dpy, surface);
1147 }
1148
1149 EGLBoolean EGLApiBase::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
1150   return driver_->fn.eglSwapIntervalFn(dpy, interval);
1151 }
1152
1153 EGLBoolean EGLApiBase::eglTerminateFn(EGLDisplay dpy) {
1154   return driver_->fn.eglTerminateFn(dpy);
1155 }
1156
1157 EGLBoolean EGLApiBase::eglWaitClientFn(void) {
1158   return driver_->fn.eglWaitClientFn();
1159 }
1160
1161 EGLBoolean EGLApiBase::eglWaitGLFn(void) {
1162   return driver_->fn.eglWaitGLFn();
1163 }
1164
1165 EGLBoolean EGLApiBase::eglWaitNativeFn(EGLint engine) {
1166   return driver_->fn.eglWaitNativeFn(engine);
1167 }
1168
1169 EGLint EGLApiBase::eglWaitSyncKHRFn(EGLDisplay dpy,
1170                                     EGLSyncKHR sync,
1171                                     EGLint flags) {
1172   return driver_->fn.eglWaitSyncKHRFn(dpy, sync, flags);
1173 }
1174
1175 EGLBoolean TraceEGLApi::eglBindAPIFn(EGLenum api) {
1176   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglBindAPI")
1177   return egl_api_->eglBindAPIFn(api);
1178 }
1179
1180 EGLBoolean TraceEGLApi::eglBindTexImageFn(EGLDisplay dpy,
1181                                           EGLSurface surface,
1182                                           EGLint buffer) {
1183   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglBindTexImage")
1184   return egl_api_->eglBindTexImageFn(dpy, surface, buffer);
1185 }
1186
1187 EGLBoolean TraceEGLApi::eglChooseConfigFn(EGLDisplay dpy,
1188                                           const EGLint* attrib_list,
1189                                           EGLConfig* configs,
1190                                           EGLint config_size,
1191                                           EGLint* num_config) {
1192   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglChooseConfig")
1193   return egl_api_->eglChooseConfigFn(dpy, attrib_list, configs, config_size,
1194                                      num_config);
1195 }
1196
1197 EGLint TraceEGLApi::eglClientWaitSyncKHRFn(EGLDisplay dpy,
1198                                            EGLSyncKHR sync,
1199                                            EGLint flags,
1200                                            EGLTimeKHR timeout) {
1201   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglClientWaitSyncKHR")
1202   return egl_api_->eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
1203 }
1204
1205 EGLBoolean TraceEGLApi::eglCopyBuffersFn(EGLDisplay dpy,
1206                                          EGLSurface surface,
1207                                          EGLNativePixmapType target) {
1208   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCopyBuffers")
1209   return egl_api_->eglCopyBuffersFn(dpy, surface, target);
1210 }
1211
1212 EGLContext TraceEGLApi::eglCreateContextFn(EGLDisplay dpy,
1213                                            EGLConfig config,
1214                                            EGLContext share_context,
1215                                            const EGLint* attrib_list) {
1216   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreateContext")
1217   return egl_api_->eglCreateContextFn(dpy, config, share_context, attrib_list);
1218 }
1219
1220 EGLImageKHR TraceEGLApi::eglCreateImageKHRFn(EGLDisplay dpy,
1221                                              EGLContext ctx,
1222                                              EGLenum target,
1223                                              EGLClientBuffer buffer,
1224                                              const EGLint* attrib_list) {
1225   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreateImageKHR")
1226   return egl_api_->eglCreateImageKHRFn(dpy, ctx, target, buffer, attrib_list);
1227 }
1228
1229 EGLSurface TraceEGLApi::eglCreatePbufferFromClientBufferFn(
1230     EGLDisplay dpy,
1231     EGLenum buftype,
1232     void* buffer,
1233     EGLConfig config,
1234     const EGLint* attrib_list) {
1235   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1236                                 "TraceGLAPI::eglCreatePbufferFromClientBuffer")
1237   return egl_api_->eglCreatePbufferFromClientBufferFn(dpy, buftype, buffer,
1238                                                       config, attrib_list);
1239 }
1240
1241 EGLSurface TraceEGLApi::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
1242                                                   EGLConfig config,
1243                                                   const EGLint* attrib_list) {
1244   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreatePbufferSurface")
1245   return egl_api_->eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
1246 }
1247
1248 EGLSurface TraceEGLApi::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
1249                                                  EGLConfig config,
1250                                                  EGLNativePixmapType pixmap,
1251                                                  const EGLint* attrib_list) {
1252   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreatePixmapSurface")
1253   return egl_api_->eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
1254 }
1255
1256 EGLSyncKHR TraceEGLApi::eglCreateSyncKHRFn(EGLDisplay dpy,
1257                                            EGLenum type,
1258                                            const EGLint* attrib_list) {
1259   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreateSyncKHR")
1260   return egl_api_->eglCreateSyncKHRFn(dpy, type, attrib_list);
1261 }
1262
1263 EGLSurface TraceEGLApi::eglCreateWindowSurfaceFn(EGLDisplay dpy,
1264                                                  EGLConfig config,
1265                                                  EGLNativeWindowType win,
1266                                                  const EGLint* attrib_list) {
1267   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreateWindowSurface")
1268   return egl_api_->eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
1269 }
1270
1271 EGLBoolean TraceEGLApi::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
1272   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroyContext")
1273   return egl_api_->eglDestroyContextFn(dpy, ctx);
1274 }
1275
1276 EGLBoolean TraceEGLApi::eglDestroyImageKHRFn(EGLDisplay dpy,
1277                                              EGLImageKHR image) {
1278   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroyImageKHR")
1279   return egl_api_->eglDestroyImageKHRFn(dpy, image);
1280 }
1281
1282 EGLBoolean TraceEGLApi::eglDestroySurfaceFn(EGLDisplay dpy,
1283                                             EGLSurface surface) {
1284   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroySurface")
1285   return egl_api_->eglDestroySurfaceFn(dpy, surface);
1286 }
1287
1288 EGLBoolean TraceEGLApi::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
1289   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroySyncKHR")
1290   return egl_api_->eglDestroySyncKHRFn(dpy, sync);
1291 }
1292
1293 EGLBoolean TraceEGLApi::eglGetConfigAttribFn(EGLDisplay dpy,
1294                                              EGLConfig config,
1295                                              EGLint attribute,
1296                                              EGLint* value) {
1297   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetConfigAttrib")
1298   return egl_api_->eglGetConfigAttribFn(dpy, config, attribute, value);
1299 }
1300
1301 EGLBoolean TraceEGLApi::eglGetConfigsFn(EGLDisplay dpy,
1302                                         EGLConfig* configs,
1303                                         EGLint config_size,
1304                                         EGLint* num_config) {
1305   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetConfigs")
1306   return egl_api_->eglGetConfigsFn(dpy, configs, config_size, num_config);
1307 }
1308
1309 EGLContext TraceEGLApi::eglGetCurrentContextFn(void) {
1310   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetCurrentContext")
1311   return egl_api_->eglGetCurrentContextFn();
1312 }
1313
1314 EGLDisplay TraceEGLApi::eglGetCurrentDisplayFn(void) {
1315   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetCurrentDisplay")
1316   return egl_api_->eglGetCurrentDisplayFn();
1317 }
1318
1319 EGLSurface TraceEGLApi::eglGetCurrentSurfaceFn(EGLint readdraw) {
1320   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetCurrentSurface")
1321   return egl_api_->eglGetCurrentSurfaceFn(readdraw);
1322 }
1323
1324 EGLDisplay TraceEGLApi::eglGetDisplayFn(EGLNativeDisplayType display_id) {
1325   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetDisplay")
1326   return egl_api_->eglGetDisplayFn(display_id);
1327 }
1328
1329 EGLint TraceEGLApi::eglGetErrorFn(void) {
1330   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetError")
1331   return egl_api_->eglGetErrorFn();
1332 }
1333
1334 EGLDisplay TraceEGLApi::eglGetPlatformDisplayEXTFn(EGLenum platform,
1335                                                    void* native_display,
1336                                                    const EGLint* attrib_list) {
1337   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetPlatformDisplayEXT")
1338   return egl_api_->eglGetPlatformDisplayEXTFn(platform, native_display,
1339                                               attrib_list);
1340 }
1341
1342 __eglMustCastToProperFunctionPointerType TraceEGLApi::eglGetProcAddressFn(
1343     const char* procname) {
1344   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetProcAddress")
1345   return egl_api_->eglGetProcAddressFn(procname);
1346 }
1347
1348 EGLBoolean TraceEGLApi::eglGetSyncAttribKHRFn(EGLDisplay dpy,
1349                                               EGLSyncKHR sync,
1350                                               EGLint attribute,
1351                                               EGLint* value) {
1352   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetSyncAttribKHR")
1353   return egl_api_->eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
1354 }
1355
1356 EGLBoolean TraceEGLApi::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
1357                                                    EGLSurface surface,
1358                                                    EGLuint64CHROMIUM* ust,
1359                                                    EGLuint64CHROMIUM* msc,
1360                                                    EGLuint64CHROMIUM* sbc) {
1361   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetSyncValuesCHROMIUM")
1362   return egl_api_->eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc);
1363 }
1364
1365 EGLBoolean TraceEGLApi::eglInitializeFn(EGLDisplay dpy,
1366                                         EGLint* major,
1367                                         EGLint* minor) {
1368   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglInitialize")
1369   return egl_api_->eglInitializeFn(dpy, major, minor);
1370 }
1371
1372 EGLBoolean TraceEGLApi::eglMakeCurrentFn(EGLDisplay dpy,
1373                                          EGLSurface draw,
1374                                          EGLSurface read,
1375                                          EGLContext ctx) {
1376   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglMakeCurrent")
1377   return egl_api_->eglMakeCurrentFn(dpy, draw, read, ctx);
1378 }
1379
1380 EGLBoolean TraceEGLApi::eglPostSubBufferNVFn(EGLDisplay dpy,
1381                                              EGLSurface surface,
1382                                              EGLint x,
1383                                              EGLint y,
1384                                              EGLint width,
1385                                              EGLint height) {
1386   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglPostSubBufferNV")
1387   return egl_api_->eglPostSubBufferNVFn(dpy, surface, x, y, width, height);
1388 }
1389
1390 EGLenum TraceEGLApi::eglQueryAPIFn(void) {
1391   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryAPI")
1392   return egl_api_->eglQueryAPIFn();
1393 }
1394
1395 EGLBoolean TraceEGLApi::eglQueryContextFn(EGLDisplay dpy,
1396                                           EGLContext ctx,
1397                                           EGLint attribute,
1398                                           EGLint* value) {
1399   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryContext")
1400   return egl_api_->eglQueryContextFn(dpy, ctx, attribute, value);
1401 }
1402
1403 const char* TraceEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
1404   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryString")
1405   return egl_api_->eglQueryStringFn(dpy, name);
1406 }
1407
1408 EGLBoolean TraceEGLApi::eglQuerySurfaceFn(EGLDisplay dpy,
1409                                           EGLSurface surface,
1410                                           EGLint attribute,
1411                                           EGLint* value) {
1412   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQuerySurface")
1413   return egl_api_->eglQuerySurfaceFn(dpy, surface, attribute, value);
1414 }
1415
1416 EGLBoolean TraceEGLApi::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
1417                                                       EGLSurface surface,
1418                                                       EGLint attribute,
1419                                                       void** value) {
1420   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1421                                 "TraceGLAPI::eglQuerySurfacePointerANGLE")
1422   return egl_api_->eglQuerySurfacePointerANGLEFn(dpy, surface, attribute,
1423                                                  value);
1424 }
1425
1426 EGLBoolean TraceEGLApi::eglReleaseTexImageFn(EGLDisplay dpy,
1427                                              EGLSurface surface,
1428                                              EGLint buffer) {
1429   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglReleaseTexImage")
1430   return egl_api_->eglReleaseTexImageFn(dpy, surface, buffer);
1431 }
1432
1433 EGLBoolean TraceEGLApi::eglReleaseThreadFn(void) {
1434   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglReleaseThread")
1435   return egl_api_->eglReleaseThreadFn();
1436 }
1437
1438 EGLBoolean TraceEGLApi::eglSurfaceAttribFn(EGLDisplay dpy,
1439                                            EGLSurface surface,
1440                                            EGLint attribute,
1441                                            EGLint value) {
1442   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglSurfaceAttrib")
1443   return egl_api_->eglSurfaceAttribFn(dpy, surface, attribute, value);
1444 }
1445
1446 EGLBoolean TraceEGLApi::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
1447   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglSwapBuffers")
1448   return egl_api_->eglSwapBuffersFn(dpy, surface);
1449 }
1450
1451 EGLBoolean TraceEGLApi::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
1452   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglSwapInterval")
1453   return egl_api_->eglSwapIntervalFn(dpy, interval);
1454 }
1455
1456 EGLBoolean TraceEGLApi::eglTerminateFn(EGLDisplay dpy) {
1457   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglTerminate")
1458   return egl_api_->eglTerminateFn(dpy);
1459 }
1460
1461 EGLBoolean TraceEGLApi::eglWaitClientFn(void) {
1462   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitClient")
1463   return egl_api_->eglWaitClientFn();
1464 }
1465
1466 EGLBoolean TraceEGLApi::eglWaitGLFn(void) {
1467   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitGL")
1468   return egl_api_->eglWaitGLFn();
1469 }
1470
1471 EGLBoolean TraceEGLApi::eglWaitNativeFn(EGLint engine) {
1472   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitNative")
1473   return egl_api_->eglWaitNativeFn(engine);
1474 }
1475
1476 EGLint TraceEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
1477                                      EGLSyncKHR sync,
1478                                      EGLint flags) {
1479   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitSyncKHR")
1480   return egl_api_->eglWaitSyncKHRFn(dpy, sync, flags);
1481 }
1482
1483 }  // namespace gfx