Respect the disabled extension list during binding initialization.

ui/gl/generate_bindings.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """code generator for GL/GLES extension wrangler."""
 
 import optparse
 import os
 import collections
 import re
 import platform
 import sys
 from subprocess import call
 from collections import namedtuple
 
 HEADER_PATHS = [
   '../../third_party/khronos',
   '../../third_party/mesa/src/include',
   '.',
   '../../gpu',
 ]
 
 UNCONDITIONALLY_BOUND_EXTENSIONS = set([
   'WGL_ARB_extensions_string',
   'WGL_EXT_extensions_string',
   'GL_CHROMIUM_gles_depth_binding_hack', # crbug.com/448206
   'GL_CHROMIUM_glgetstringi_hack', # crbug.com/470396
+  'GL_CHROMIUM_EGL_KHR_fence_sync_bind_always_504758_hack', # crbug.com/504758

[Ken Russell (switch to Gerrit), 2015/06/26 17:06:49]

That's a mouthful. Is it really worth embedding the bug ID in the name of the
hack?

[no sievers, 2015/06/26 17:51:29]

Yea sorry that was my overly explicit suggestion, something more compact sounds
good :)

 ])
 
 """Function binding conditions can be specified manually by supplying a versions
 array instead of the names array. Each version has the following keys:
    name: Mandatory. Name of the function. Multiple versions can have the same
          name but different conditions.
    extensions: Extra Extensions for which the function is bound. Only needed
                in some cases where the extension cannot be parsed from the
                headers.
 
@@ skipping 1156 matching lines @@
   'arguments': 'EGLenum api', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglBindTexImage'],
   'arguments': 'EGLDisplay dpy, EGLSurface surface, EGLint buffer', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglChooseConfig'],
   'arguments': 'EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, '
                'EGLint config_size, EGLint* num_config', },
 { 'return_type': 'EGLint',
   'versions': [{ 'name': 'eglClientWaitSyncKHR',
-                 'extensions': ['EGL_KHR_fence_sync'] }],
+                 'extensions': [
+                   'EGL_KHR_fence_sync',
+                   'GL_CHROMIUM_EGL_KHR_fence_sync_bind_always_504758_hack'
+                 ] }],
   'arguments': 'EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, '
       'EGLTimeKHR timeout' },
 { 'return_type': 'EGLBoolean',
   'names': ['eglCopyBuffers'],
   'arguments':
       'EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target', },
 { 'return_type': 'EGLContext',
   'names': ['eglCreateContext'],
   'arguments': 'EGLDisplay dpy, EGLConfig config, EGLContext share_context, '
               'const EGLint* attrib_list', },
@@ skipping 11 matching lines @@
       'const EGLint* attrib_list', },
 { 'return_type': 'EGLSurface',
   'names': ['eglCreatePbufferSurface'],
   'arguments': 'EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list', },
 { 'return_type': 'EGLSurface',
   'names': ['eglCreatePixmapSurface'],
   'arguments': 'EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, '
                'const EGLint* attrib_list', },
 { 'return_type': 'EGLSyncKHR',
   'versions': [{ 'name': 'eglCreateSyncKHR',
-                 'extensions': ['EGL_KHR_fence_sync'] }],
+                 'extensions': [
+                   'EGL_KHR_fence_sync',
+                   'GL_CHROMIUM_EGL_KHR_fence_sync_bind_always_504758_hack'
+                 ] }],
   'arguments': 'EGLDisplay dpy, EGLenum type, const EGLint* attrib_list' },
 { 'return_type': 'EGLSurface',
   'names': ['eglCreateWindowSurface'],
   'arguments': 'EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, '
                'const EGLint* attrib_list', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglDestroyContext'],
   'arguments': 'EGLDisplay dpy, EGLContext ctx', },
 { 'return_type': 'EGLBoolean',
   'versions': [{ 'name' : 'eglDestroyImageKHR',
                  'extensions': ['EGL_KHR_image_base'] }],
   'arguments': 'EGLDisplay dpy, EGLImageKHR image' },
 { 'return_type': 'EGLBoolean',
   'names': ['eglDestroySurface'],
   'arguments': 'EGLDisplay dpy, EGLSurface surface', },
 { 'return_type': 'EGLBoolean',
   'versions': [{ 'name': 'eglDestroySyncKHR',
-                 'extensions': ['EGL_KHR_fence_sync'] }],
+                 'extensions': [
+                   'EGL_KHR_fence_sync',
+                   'GL_CHROMIUM_EGL_KHR_fence_sync_bind_always_504758_hack'
+                 ] }],
   'arguments': 'EGLDisplay dpy, EGLSyncKHR sync' },
 { 'return_type': 'EGLBoolean',
   'names': ['eglGetConfigAttrib'],
   'arguments':
       'EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglGetConfigs'],
   'arguments': 'EGLDisplay dpy, EGLConfig* configs, EGLint config_size, '
                'EGLint* num_config', },
 { 'return_type': 'EGLContext',
@@ skipping 15 matching lines @@
   'known_as': 'eglGetPlatformDisplayEXT',
   'versions': [{ 'name': 'eglGetPlatformDisplayEXT',
                  'client_extensions': ['EGL_EXT_platform_base'], }],
   'arguments': 'EGLenum platform, void* native_display, '
                'const EGLint* attrib_list', },
 { 'return_type': '__eglMustCastToProperFunctionPointerType',
   'names': ['eglGetProcAddress'],
   'arguments': 'const char* procname', },
 { 'return_type': 'EGLBoolean',
   'versions': [{ 'name': 'eglGetSyncAttribKHR',
-                 'extensions': ['EGL_KHR_fence_sync'] }],
+                 'extensions': [
+                   'EGL_KHR_fence_sync',
+                   'GL_CHROMIUM_EGL_KHR_fence_sync_bind_always_504758_hack'
+                 ] }],
   'arguments': 'EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, '
       'EGLint* value' },
 { 'return_type': 'EGLBoolean',
   'names': ['eglGetSyncValuesCHROMIUM'],
   'arguments':
       'EGLDisplay dpy, EGLSurface surface, '
       'EGLuint64CHROMIUM* ust, EGLuint64CHROMIUM* msc, '
       'EGLuint64CHROMIUM* sbc', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglInitialize'],
@@ skipping 596 matching lines @@
       first_version = False
 
   # TODO(jmadill): make more robust
   def IsClientExtensionFunc(func):
     assert len(func['versions']) > 0
     if 'client_extensions' in func['versions'][0]:
       assert len(func['versions']) == 1
       return True
     return False
 
-  if set_name == 'egl':
-    file.write("""std::string client_extensions(GetClientExtensions());
-  client_extensions += " ";
-  ALLOW_UNUSED_LOCAL(client_extensions);
-
-""")
-    for extension in sorted(used_client_extensions):
-      # Extra space at the end of the extension name is intentional,
-      # it is used as a separator
-      file.write(
-          '  ext.b_%s = client_extensions.find("%s ") != std::string::npos;\n' %
-          (extension, extension))
-    for func in functions:
-      if not 'static_binding' in func and IsClientExtensionFunc(func):
-        file.write('\n')
-        file.write('  debug_fn.%sFn = 0;\n' % func['known_as'])
-        WriteConditionalFuncBinding(file, func)
+  file.write("}\n\n");
 
   if set_name == 'gl':
-    # Write the deferred bindings for GL that need a current context and depend
-    # on GL_VERSION and GL_EXTENSIONS.
-    file.write('}\n\n')
-    file.write("""void DriverGL::InitializeDynamicBindings(GLContext* context) {
+    file.write("""\
+void DriverGL::InitializeDynamicBindings(
+    GLContext* context) {
   DCHECK(context && context->IsCurrent(NULL));
   const GLVersionInfo* ver = context->GetVersionInfo();
   ALLOW_UNUSED_LOCAL(ver);
   std::string extensions = context->GetExtensions() + " ";
   ALLOW_UNUSED_LOCAL(extensions);
 
 """)
+  elif set_name == 'egl':
+    file.write("""\
+void DriverEGL::InitializeExtensionBindings() {
+  std::string client_extensions(GetClientExtensions());
+  client_extensions += " ";
+  ALLOW_UNUSED_LOCAL(client_extensions);
+
+""")
   else:
-    file.write("""std::string extensions(GetPlatformExtensions());
+    file.write("""\
+void Driver%s::InitializeExtensionBindings() {
+  std::string extensions(GetPlatformExtensions());
+  extensions += " ";
+  ALLOW_UNUSED_LOCAL(extensions);
+
+""" % (set_name.upper(),))
+
+  def OutputExtensionBindings(extension_var, extensions, extension_funcs):
+    # Extra space at the end of the extension name is intentional,
+    # it is used as a separator
+    for extension in extensions:
+      file.write('  ext.b_%s = %s.find("%s ") != std::string::npos;\n' %
+                 (extension, extension_var, extension))
+
+    for func in extension_funcs:
+      if not 'static_binding' in func:
+        file.write('\n')
+        file.write('  debug_fn.%sFn = 0;\n' % func['known_as'])
+        WriteConditionalFuncBinding(file, func)
+
+  OutputExtensionBindings(
+    'client_extensions',
+    sorted(used_client_extensions),
+    [ f for f in functions if IsClientExtensionFunc(f) ])
+
+  if set_name == 'egl':
+    file.write("""\
+  std::string extensions(GetPlatformExtensions());
   extensions += " ";
   ALLOW_UNUSED_LOCAL(extensions);
 
 """)
 
-  for extension in sorted(used_extensions):
-    # Extra space at the end of the extension name is intentional, it is used
-    # as a separator
-    file.write('  ext.b_%s = extensions.find("%s ") != std::string::npos;\n' %
-        (extension, extension))
-
-  for func in functions:
-    if not 'static_binding' in func and not IsClientExtensionFunc(func):
-      file.write('\n')
-      file.write('  debug_fn.%sFn = 0;\n' % func['known_as'])
-      WriteConditionalFuncBinding(file, func)
+  OutputExtensionBindings(
+    'extensions',
+    sorted(used_extensions),
+    [ f for f in functions if not IsClientExtensionFunc(f) ])
 
   # Some new function pointers have been added, so update them in debug bindings
   file.write('\n')
   file.write('  if (g_debugBindingsInitialized)\n')
   file.write('    InitializeDebugBindings();\n')
   file.write('}\n')
   file.write('\n')
 
   # Write logging wrappers for each function.
   file.write('extern "C" {\n')
@@ skipping 641 matching lines @@
                                     'gl_enums_implementation_autogen.h'),
                        'wb')
     GenerateEnumUtils(header_file, enum_header_filenames)
     header_file.close()
     ClangFormat(header_file.name)
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))