Take GL version and extensions correctly into account when binding functions

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 sys
 
+"""In case there are multiple versions of the same function, one that's listed
+first takes priority if its conditions are met. If the function is an extension
+function, finding the extension from the extension string is a condition for
+binding it. The last version of the function is treated as a fallback option in
+case no other versions were bound, so a non-null function pointer in the
+bindings does not guarantee that the function is supported.
+
+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.
+   gl_versions: List of GL versions where the function is found.
+   extension/extensions: Extensions where the function is found. If not

[no sievers, 2014/01/13 23:46:40]

Do we need to support both 'extension' and 'extensions'?
It seems to just make it more slightly complicated and confusing below.

[oetuaho-nv, 2014/01/14 16:39:58]

I did it this way since extension functions are mostly found only in one
extension, and leaving the list out in that case makes the function specs a bit
easier to read/write. But this isn't a very strong reason, and I'll change it so
that only 'extensions' is used to make the code simpler.

+                         specified, the extensions are determined based on GL
+                         header files.
+                         If the function exists in an extension header, you
+                         may specify an empty array to prevent making that a
+                         condition for binding.
+
+By default, the function gets its name from the first name in its names or
+versions array. This can be overridden by supplying a 'known_as' key.
+"""
 GL_FUNCTIONS = [
 { 'return_type': 'void',
   'names': ['glActiveTexture'],
   'arguments': 'GLenum texture', },
 { 'return_type': 'void',
   'names': ['glAttachShader'],
   'arguments': 'GLuint program, GLuint shader', },
 { 'return_type': 'void',
   'names': ['glBeginQuery'],
   'arguments': 'GLenum target, GLuint id', },
@@ skipping 282 matching lines @@
   'arguments': 'GLenum target, '
                'GLenum attachment, GLenum pname, GLint* params', },
 { 'return_type': 'GLenum',
   'names': ['glGetGraphicsResetStatusARB',
             'glGetGraphicsResetStatusEXT'],
   'arguments': 'void', },
 { 'return_type': 'void',
   'names': ['glGetIntegerv'],
   'arguments': 'GLenum pname, GLint* params', },
 { 'return_type': 'void',
-  'names': ['glGetProgramBinary', 'glGetProgramBinaryOES'],
+  'known_as': 'glGetProgramBinary',
+  'versions': [{ 'name': 'glGetProgramBinaryOES' },
+               { 'name': 'glGetProgramBinary',
+                 'extension': 'GL_ARB_get_program_binary' },
+               { 'name': 'glGetProgramBinary' }],
   'arguments': 'GLuint program, GLsizei bufSize, GLsizei* length, '
-               'GLenum* binaryFormat, GLvoid* binary',
-  'other_extensions': ['ARB_get_program_binary',
-                       'OES_get_program_binary'] },
+               'GLenum* binaryFormat, GLvoid* binary' },
 { 'return_type': 'void',
   'names': ['glGetProgramiv'],
   'arguments': 'GLuint program, GLenum pname, GLint* params', },
 { 'return_type': 'void',
   'names': ['glGetProgramInfoLog'],
   'arguments':
       'GLuint program, GLsizei bufsize, GLsizei* length, char* infolog', },
 { 'return_type': 'void',
   'names': ['glGetQueryiv'],
   'arguments': 'GLenum target, GLenum pname, GLint* params', },
@@ skipping 97 matching lines @@
 { 'return_type': 'GLboolean',
   'names': ['glIsTexture'],
   'arguments': 'GLuint texture', },
 { 'return_type': 'void',
   'names': ['glLineWidth'],
   'arguments': 'GLfloat width', },
 { 'return_type': 'void',
   'names': ['glLinkProgram'],
   'arguments': 'GLuint program', },
 { 'return_type': 'void*',
-  'names': ['glMapBuffer', 'glMapBufferOES'],
+  'known_as': 'glMapBuffer',
+  'names': ['glMapBufferOES', 'glMapBuffer'],
   'arguments': 'GLenum target, GLenum access', },
 { 'return_type': 'void*',
   'names': ['glMapBufferRange'],
   'arguments':
       'GLenum target, GLintptr offset, GLsizeiptr length, GLenum access', },
 { 'return_type': 'void',
   'names': ['glFlushMappedBufferRange'],
   'arguments': 'GLenum target, GLintptr offset, GLsizeiptr length', },
 { 'return_type': 'void',
   'names': ['glPixelStorei'],
   'arguments': 'GLenum pname, GLint param', },
 { 'return_type': 'void',
   'names': ['glPointParameteri'],
   'arguments': 'GLenum pname, GLint param', },
 { 'return_type': 'void',
   'names': ['glPolygonOffset'],
   'arguments': 'GLfloat factor, GLfloat units', },
 { 'return_type': 'void',
-  'names': ['glProgramBinary', 'glProgramBinaryOES'],
+  'known_as': 'glProgramBinary',
+  'versions': [{ 'name': 'glProgramBinaryOES' },
+               { 'name': 'glProgramBinary',
+                 'extension': 'GL_ARB_get_program_binary' },
+               { 'name': 'glProgramBinary' }],
   'arguments': 'GLuint program, GLenum binaryFormat, '
-               'const GLvoid* binary, GLsizei length',
-  'other_extensions': ['ARB_get_program_binary',
-                       'OES_get_program_binary'] },
+               'const GLvoid* binary, GLsizei length' },
 { 'return_type': 'void',
-  'names': ['glProgramParameteri'],
-  'arguments': 'GLuint program, GLenum pname, GLint value',
-  'other_extensions': ['ARB_get_program_binary'] },
+  'versions': [{ 'name': 'glProgramParameteri',
+                 'extension': 'GL_ARB_get_program_binary' },
+               { 'name': 'glProgramParameteri' }],
+  'arguments': 'GLuint program, GLenum pname, GLint value' },
 { 'return_type': 'void',
   'names': ['glQueryCounter'],
   'arguments': 'GLuint id, GLenum target', },
 { 'return_type': 'void',
   'names': ['glReadBuffer'],
   'arguments': 'GLenum src', },
 { 'return_type': 'void',
   'names': ['glReadPixels'],
   'arguments':
     'GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, '
     'GLenum type, void* pixels', },
 { 'return_type': 'void',
   'names': ['glReleaseShaderCompiler'],
   'arguments': 'void', },
+# Multisampling API is different in different GL versions, some require an
+# explicit resolve step for renderbuffers and/or FBO texture attachments and
+# some do not. Multiple alternatives might be present in a single
+# implementation, which require different use of the API and may have
+# different performance (explicit resolve performing worse, for example).
+# So even though the function signature is the same across versions, we split
+# their definitions so that the function to use can be chosen correctly at a
+# higher level.
+# TODO(oetuaho@nvidia.com): Some of these might still be possible to combine.
+# This could also fix weirdness in the mock bindings that's caused by the same
+# function name appearing multiple times.
+# This is the ES3 function, which requires explicit resolve:
 { 'return_type': 'void',
   'names': ['glRenderbufferStorageMultisample'],
   'arguments': 'GLenum target, GLsizei samples, GLenum internalformat, '
                'GLsizei width, GLsizei height', },
+# In desktop GL, EXT and core versions both have an explicit resolve step,
+# though desktop core GL implicitly resolves when drawing to a window.
+# TODO(oetuaho@nvidia.com): Right now this function also doubles as ES2 EXT
+# function, which has implicit resolve, and for which the fallback is wrong.
+# Fix this.
 { 'return_type': 'void',
   'names': ['glRenderbufferStorageMultisampleEXT',
             'glRenderbufferStorageMultisample'],
   'arguments': 'GLenum target, GLsizei samples, GLenum internalformat, '
                'GLsizei width, GLsizei height', },
 { 'return_type': 'void',
   'names': ['glRenderbufferStorageMultisampleANGLE',
             'glRenderbufferStorageMultisample'],
   'arguments': 'GLenum target, GLsizei samples, GLenum internalformat, '
                'GLsizei width, GLsizei height', },
@@ skipping 10 matching lines @@
   'arguments': 'GLclampf value, GLboolean invert', },
 { 'return_type': 'void',
   'names': ['glScissor'],
   'arguments': 'GLint x, GLint y, GLsizei width, GLsizei height', },
 { 'return_type': 'void',
   'names': ['glShaderBinary'],
   'arguments': 'GLsizei n, const GLuint* shaders, GLenum binaryformat, '
                'const void* binary, GLsizei length', },
 { 'return_type': 'void',
   'names': ['glShaderSource'],
-  'arguments':
-      'GLuint shader, GLsizei count, const char* const* str, const GLint* length',
+  'arguments': 'GLuint shader, GLsizei count, const char* const* str, '
+               'const GLint* length',
   'logging_code': """
   GL_SERVICE_LOG_CODE_BLOCK({
     for (GLsizei ii = 0; ii < count; ++ii) {
       if (str[ii]) {
         if (length && length[ii] >= 0) {
           std::string source(str[ii], length[ii]);
           GL_SERVICE_LOG("  " << ii << ": ---\\n" << source << "\\n---");
         } else {
           GL_SERVICE_LOG("  " << ii << ": ---\\n" << str[ii] << "\\n---");
         }
@@ skipping 103 matching lines @@
                'GLboolean transpose, const GLfloat* value', },
 { 'return_type': 'void',
   'names': ['glUniformMatrix3fv'],
   'arguments': 'GLint location, GLsizei count, '
                'GLboolean transpose, const GLfloat* value', },
 { 'return_type': 'void',
   'names': ['glUniformMatrix4fv'],
   'arguments': 'GLint location, GLsizei count, '
                'GLboolean transpose, const GLfloat* value', },
 { 'return_type': 'GLboolean',
-  'names': ['glUnmapBuffer', 'glUnmapBufferOES'],
+  'known_as': 'glUnmapBuffer',
+  'names': ['glUnmapBufferOES', 'glUnmapBuffer'],
   'arguments': 'GLenum target', },
 { 'return_type': 'void',
   'names': ['glUseProgram'],
   'arguments': 'GLuint program', },
 { 'return_type': 'void',
   'names': ['glValidateProgram'],
   'arguments': 'GLuint program', },
 { 'return_type': 'void',
   'names': ['glVertexAttrib1f'],
   'arguments': 'GLuint indx, GLfloat x', },
@@ skipping 55 matching lines @@
 { 'return_type': 'void',
   'names': ['glGetSynciv'],
   'arguments':
     'GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length,'
     'GLint* values', },
 { 'return_type': 'GLenum',
   'names': ['glClientWaitSync'],
   'arguments':
     'GLsync sync, GLbitfield flags, GLuint64 timeout', },
 { 'return_type': 'void',
-  'names': ['glDrawArraysInstancedANGLE', 'glDrawArraysInstancedARB'],
+  'known_as': 'glDrawArraysInstancedANGLE',
+  'names': ['glDrawArraysInstancedARB', 'glDrawArraysInstancedANGLE'],
   'arguments': 'GLenum mode, GLint first, GLsizei count, GLsizei primcount', },
 { 'return_type': 'void',
-  'names': ['glDrawElementsInstancedANGLE', 'glDrawElementsInstancedARB'],
+  'known_as': 'glDrawElementsInstancedANGLE',
+  'names': ['glDrawElementsInstancedARB', 'glDrawElementsInstancedANGLE'],
   'arguments':
       'GLenum mode, GLsizei count, GLenum type, const void* indices, '
       'GLsizei primcount', },
 { 'return_type': 'void',
-  'names': ['glVertexAttribDivisorANGLE', 'glVertexAttribDivisorARB'],
+  'known_as': 'glVertexAttribDivisorANGLE',
+  'names': ['glVertexAttribDivisorARB', 'glVertexAttribDivisorANGLE'],
   'arguments':
       'GLuint index, GLuint divisor', },
 { 'return_type': 'void',
-  'names': ['glGenVertexArraysOES',
-            'glGenVertexArraysAPPLE',
-            'glGenVertexArrays'],
-  'arguments': 'GLsizei n, GLuint* arrays',
-  'other_extensions': ['OES_vertex_array_object',
-                       'APPLE_vertex_array_object',
-                       'ARB_vertex_array_object'] },
+  'known_as': 'glGenVertexArraysOES',
+  'versions': [{ 'name': 'glGenVertexArrays',
+                 'gl_versions': ['gl3', 'gl4'] },
+               { 'name': 'glGenVertexArrays',
+                 'extension': 'GL_ARB_vertex_array_object' },
+               { 'name': 'glGenVertexArraysOES' },
+               { 'name': 'glGenVertexArraysAPPLE',
+                 'extension': 'GL_APPLE_vertex_array_object' }],
+  'arguments': 'GLsizei n, GLuint* arrays', },
 { 'return_type': 'void',
-  'names': ['glDeleteVertexArraysOES',
-            'glDeleteVertexArraysAPPLE',
-            'glDeleteVertexArrays'],
-  'arguments': 'GLsizei n, const GLuint* arrays',
-  'other_extensions': ['OES_vertex_array_object',
-                       'APPLE_vertex_array_object',
-                       'ARB_vertex_array_object'] },
+  'known_as': 'glDeleteVertexArraysOES',
+  'versions': [{ 'name': 'glDeleteVertexArrays',
+                 'gl_versions': ['gl3', 'gl4'] },
+               { 'name': 'glDeleteVertexArrays',
+                 'extension': 'GL_ARB_vertex_array_object' },
+               { 'name': 'glDeleteVertexArraysOES' },
+               { 'name': 'glDeleteVertexArraysAPPLE',
+                 'extension': 'GL_APPLE_vertex_array_object' }],
+  'arguments': 'GLsizei n, const GLuint* arrays' },
 { 'return_type': 'void',
-  'names': ['glBindVertexArrayOES',
-            'glBindVertexArrayAPPLE',
-            'glBindVertexArray'],
-  'arguments': 'GLuint array',
-  'other_extensions': ['OES_vertex_array_object',
-                       'APPLE_vertex_array_object',
-                       'ARB_vertex_array_object'] },
+  'known_as': 'glBindVertexArrayOES',
+  'versions': [{ 'name': 'glBindVertexArray',
+                 'gl_versions': ['gl3', 'gl4'] },
+               { 'name': 'glBindVertexArray',
+                 'extension': 'GL_ARB_vertex_array_object' },
+               { 'name': 'glBindVertexArrayOES' },
+               { 'name': 'glBindVertexArrayAPPLE',
+                 'extension': 'GL_APPLE_vertex_array_object' }],
+  'arguments': 'GLuint array' },
 { 'return_type': 'GLboolean',
-  'names': ['glIsVertexArrayOES',
-            'glIsVertexArrayAPPLE',
-            'glIsVertexArray'],
-  'arguments': 'GLuint array',
-  'other_extensions': ['OES_vertex_array_object',
-                       'APPLE_vertex_array_object',
-                       'ARB_vertex_array_object'] },
+  'known_as': 'glIsVertexArrayOES',
+  'versions': [{ 'name': 'glIsVertexArray',
+                 'gl_versions': ['gl3', 'gl4'] },
+               { 'name': 'glIsVertexArray',
+                 'extension': 'GL_ARB_vertex_array_object' },
+               { 'name': 'glIsVertexArrayOES' },
+               { 'name': 'glIsVertexArrayAPPLE',
+                 'extension': 'GL_APPLE_vertex_array_object' }],
+  'arguments': 'GLuint array' },
 { 'return_type': 'void',
-  'names': ['glDiscardFramebufferEXT', 'glInvalidateFramebuffer'],
+  'known_as': 'glDiscardFramebufferEXT',
+  'versions': [{ 'name': 'glInvalidateFramebuffer',
+                 'gl_versions': ['es3'],
+                 'extensions': [] },
+               { 'name': 'glDiscardFramebufferEXT',
+                 'gl_versions': ['es1', 'es2'] }],
   'arguments': 'GLenum target, GLsizei numAttachments, '
       'const GLenum* attachments' },
 ]
 
 GL_NULLDRAW_FUNCTIONS = [
 { 'return_type': 'void',
   'names': ['glClear'],
   'arguments': 'GLbitfield mask', },
 { 'return_type': 'void',
   'names': ['glDrawArrays'],
@@ skipping 68 matching lines @@
                'EGLint* num_config', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglChooseConfig'],
   'arguments': 'EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, '
                'EGLint config_size, EGLint* num_config', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglGetConfigAttrib'],
   'arguments':
       'EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value', },
 { 'return_type': 'EGLImageKHR',
-  'names': ['eglCreateImageKHR'],
+  'versions': [{ 'name': 'eglCreateImageKHR',
+                 'extension': 'EGL_KHR_image_base' }],
   'arguments':
       'EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, '
-      'const EGLint* attrib_list',
-  'other_extensions': ['EGL_KHR_image_base'] },
+      'const EGLint* attrib_list' },
 { 'return_type': 'EGLBoolean',
-  'names': ['eglDestroyImageKHR'],
-  'arguments': 'EGLDisplay dpy, EGLImageKHR image',
-  'other_extensions': ['EGL_KHR_image_base'] },
+  'versions': [{ 'name' : 'eglDestroyImageKHR',
+                 'extension': 'EGL_KHR_image_base' }],
+  'arguments': 'EGLDisplay dpy, EGLImageKHR image' },
 { 'return_type': 'EGLSurface',
   'names': ['eglCreateWindowSurface'],
   'arguments': 'EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, '
                '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, '
@@ skipping 77 matching lines @@
   'arguments': 'const char* procname', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglPostSubBufferNV'],
   'arguments': 'EGLDisplay dpy, EGLSurface surface, '
     'EGLint x, EGLint y, EGLint width, EGLint height', },
 { 'return_type': 'EGLBoolean',
   'names': ['eglQuerySurfacePointerANGLE'],
   'arguments':
       'EGLDisplay dpy, EGLSurface surface, EGLint attribute, void** value', },
 { 'return_type': 'EGLSyncKHR',
-  'names': ['eglCreateSyncKHR'],
-  'arguments': 'EGLDisplay dpy, EGLenum type, const EGLint* attrib_list',
-  'other_extensions': ['EGL_KHR_fence_sync'] },
+  'versions': [{ 'name': 'eglCreateSyncKHR',
+                 'extension': 'EGL_KHR_fence_sync' }],
+  'arguments': 'EGLDisplay dpy, EGLenum type, const EGLint* attrib_list' },
 { 'return_type': 'EGLint',
-  'names': ['eglClientWaitSyncKHR'],
+  'versions': [{ 'name': 'eglClientWaitSyncKHR',
+                 'extension': 'EGL_KHR_fence_sync' }],
   'arguments': 'EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, '
-      'EGLTimeKHR timeout',
-  'other_extensions': ['EGL_KHR_fence_sync'] },
+      'EGLTimeKHR timeout' },
 { 'return_type': 'EGLBoolean',
-  'names': ['eglGetSyncAttribKHR'],
+  'versions': [{ 'name': 'eglGetSyncAttribKHR',
+                 'extension': 'EGL_KHR_fence_sync' }],
   'arguments': 'EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, '
-      'EGLint* value',
-  'other_extensions': ['EGL_KHR_fence_sync'] },
+      'EGLint* value' },
 { 'return_type': 'EGLBoolean',
-  'names': ['eglDestroySyncKHR'],
-  'arguments': 'EGLDisplay dpy, EGLSyncKHR sync',
-  'other_extensions': ['EGL_KHR_fence_sync'] },
+  'versions': [{ 'name': 'eglDestroySyncKHR',
+                 'extension': 'EGL_KHR_fence_sync' }],
+  'arguments': 'EGLDisplay dpy, EGLSyncKHR sync' },
 { 'return_type': 'EGLBoolean',
   'names': ['eglGetSyncValuesCHROMIUM'],
   'arguments':
       'EGLDisplay dpy, EGLSurface surface, '
       'EGLuint64CHROMIUM* ust, EGLuint64CHROMIUM* msc, '
       'EGLuint64CHROMIUM* sbc', },
 { 'return_type': 'EGLint',
-  'names': ['eglWaitSyncKHR'],
-  'arguments': 'EGLDisplay dpy, EGLSyncKHR sync, EGLint flags',
-  'other_extensions': ['EGL_KHR_wait_sync'] },
+  'versions': [{ 'name': 'eglWaitSyncKHR',
+                 'extension': 'EGL_KHR_fence_sync' }],
+  'arguments': 'EGLDisplay dpy, EGLSyncKHR sync, EGLint flags' }
 ]
 
 WGL_FUNCTIONS = [
 { 'return_type': 'HGLRC',
   'names': ['wglCreateContext'],
   'arguments': 'HDC hdc', },
 { 'return_type': 'HGLRC',
   'names': ['wglCreateLayerContext'],
   'arguments': 'HDC hdc, int iLayerPlane', },
 { 'return_type': 'BOOL',
@@ skipping 229 matching lines @@
     ],
     [
       'EGL_ANGLE_d3d_share_handle_client_buffer',
       'EGL_ANGLE_surface_d3d_texture_2d_share_handle',
     ],
   ],
   [WGL_FUNCTIONS, [], 'wgl', ['GL/wglext.h'], []],
   [GLX_FUNCTIONS, [], 'glx', ['GL/glx.h', 'GL/glxext.h'], []],
 ]
 
-def GenerateHeader(file, functions, set_name, used_extension_functions):
+def GenerateHeader(file, functions, set_name, used_extensions):
   """Generates gl_bindings_autogen_x.h"""
 
   # Write file header.
   file.write(
 """// 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.
 
 // This file is automatically generated.
 
 #ifndef UI_GFX_GL_GL_BINDINGS_AUTOGEN_%(name)s_H_
 #define UI_GFX_GL_GL_BINDINGS_AUTOGEN_%(name)s_H_
 
 namespace gfx {
 
 class GLContext;
 
 """ % {'name': set_name.upper()})
 
   # Write typedefs for function pointer types. Always use the GL name for the
   # typedef.
   file.write('\n')
   for func in functions:
     file.write('typedef %s (GL_BINDING_CALL *%sProc)(%s);\n' %
-        (func['return_type'], func['names'][0], func['arguments']))
+        (func['return_type'], func['known_as'], func['arguments']))
 
   # Write declarations for booleans indicating which extensions are available.
   file.write('\n')
   file.write("struct Extensions%s {\n" % set_name.upper())
-  for extension, ext_functions in used_extension_functions:
+  for extension in used_extensions:
     file.write('  bool b_%s;\n' % extension)
   file.write('};\n')
   file.write('\n')
 
   # Write Procs struct.
   file.write("struct Procs%s {\n" % set_name.upper())
   for func in functions:
-    file.write('  %sProc %sFn;\n' % (func['names'][0], func['names'][0]))
+    file.write('  %sProc %sFn;\n' % (func['known_as'], func['known_as']))
   file.write('};\n')
   file.write('\n')
 
   # Write Api class.
   file.write(
 """class GL_EXPORT %(name)sApi {
  public:
   %(name)sApi();
   virtual ~%(name)sApi();
 
 """ % {'name': set_name.upper()})
   for func in functions:
     file.write('  virtual %s %sFn(%s) = 0;\n' %
-      (func['return_type'], func['names'][0], func['arguments']))
+      (func['return_type'], func['known_as'], func['arguments']))
   file.write('};\n')
   file.write('\n')
 
   file.write( '}  // namespace gfx\n')
 
   # Write macros to invoke function pointers. Always use the GL name for the
   # macro.
   file.write('\n')
   for func in functions:
     file.write('#define %s ::gfx::g_current_%s_context->%sFn\n' %
-        (func['names'][0], set_name.lower(), func['names'][0]))
+        (func['known_as'], set_name.lower(), func['known_as']))
 
   file.write('\n')
   file.write('#endif  //  UI_GFX_GL_GL_BINDINGS_AUTOGEN_%s_H_\n' %
       set_name.upper())
 
 
-def GenerateAPIHeader(file, functions, set_name, used_extension_functions):
+def GenerateAPIHeader(file, functions, set_name):
   """Generates gl_bindings_api_autogen_x.h"""
 
   # Write file header.
   file.write(
 """// 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.
 
 // This file is automatically generated.
 
 """ % {'name': set_name.upper()})
 
   # Write API declaration.
   for func in functions:
     file.write('  virtual %s %sFn(%s) OVERRIDE;\n' %
-      (func['return_type'], func['names'][0], func['arguments']))
+      (func['return_type'], func['known_as'], func['arguments']))
 
   file.write('\n')
 
 
-def GenerateMockHeader(file, functions, set_name, used_extension_functions):
+def GenerateMockHeader(file, functions, set_name):
   """Generates gl_mock_autogen_x.h"""
 
   # Write file header.
   file.write(
 """// 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.
 
 // This file is automatically generated.
 
 """ % {'name': set_name.upper()})
 
   # Write API declaration.
   for func in functions:
     args = func['arguments']
     if args == 'void':
       args = ''
     arg_count = 0
     if len(args):
       arg_count = func['arguments'].count(',') + 1
     file.write('  MOCK_METHOD%d(%s, %s(%s));\n' %
-      (arg_count, func['names'][0][2:], func['return_type'], args))
+      (arg_count, func['known_as'][2:], func['return_type'], args))
 
   file.write('\n')
 
 
-def GenerateInterfaceHeader(
-    file, functions, set_name, used_extension_functions):
+def GenerateInterfaceHeader(file, functions, set_name):
   """Generates gl_interface_autogen_x.h"""
 
   # Write file header.
   file.write(
 """// 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.
 
 // This file is automatically generated.
 
 """ % {'name': set_name.upper()})
 
   # Write API declaration.
   for func in functions:
     args = func['arguments']
     if args == 'void':
       args = ''
     file.write('  virtual %s %s(%s) = 0;\n' %
-      (func['return_type'], func['names'][0][2:], args))
+      (func['return_type'], func['known_as'][2:], args))
 
   file.write('\n')
 
 
 def GenerateSource(
-  file, functions, nulldraw_functions, set_name, used_extension_functions):
+  file, functions, nulldraw_functions, set_name, used_extensions):
   """Generates gl_bindings_autogen_x.cc"""
 
   # Write file header.
   file.write(
 """// Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file is automatically generated.
 
 #include <string>
 #include "base/debug/trace_event.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_version_info.h"
 #include "ui/gl/gl_%s_api_implementation.h"
 
 using gpu::gles2::GLES2Util;
 
 namespace gfx {
 """ % set_name.lower())
 
-  # Write definitions of function pointers.
   file.write('\n')
   file.write('static bool g_debugBindingsInitialized;\n')
   file.write('Driver%s g_driver_%s;\n' % (set_name.upper(), set_name.lower()))
   file.write('\n')
 
-  # Write function to initialize the core function pointers. The code assumes
-  # any non-NULL pointer returned by GetGLCoreProcAddress() is valid, although
-  # it may be overwritten by an extension function pointer later.
+  # Write stub functions that take the place of some functions before a context
+  # is initialized. This is done to provide clear asserts on debug build and to
+  # avoid crashing in case of a bug on release build.
   file.write('\n')
-  file.write('void Driver%s::InitializeBindings() {\n' %
+  for func in functions:
+    if len(func['names']) > 1:
+      file.write('%s %sNotBound(%s) {\n' %
+          (func['return_type'], func['known_as'], func['arguments']))
+      file.write('  NOTREACHED();\n')
+      return_type = func['return_type'].lower()
+      # Returning 0 works for booleans, integers and pointers.
+      if return_type != 'void':
+        file.write('  return 0;\n')
+      file.write('}\n')
+
+  # Write function to initialize the function pointers that are always the same
+  # and to initialize bindings where choice of the function depends on the
+  # extension string or the GL version to point to stub functions.
+  file.write('\n')
+  file.write('void Driver%s::InitializeStaticBindings() {\n' %
              set_name.upper())
+
+  def WriteFuncBinding(file, known_as, version_name):
+    file.write(
+        '  fn.%sFn = reinterpret_cast<%sProc>(GetGLProcAddress("%s"));\n' %
+        (known_as, known_as, version_name))
+
   for func in functions:
-    first_name = func['names'][0]
-    for i, name in enumerate(func['names']):
-      if i:
-        file.write('  if (!fn.%sFn)\n  ' % first_name)
-      file.write(
-          '  fn.%sFn = reinterpret_cast<%sProc>('
-          'GetGLCoreProcAddress("%s"));\n' %
-          (first_name, first_name, name))
+    if len(func['names']) == 1:

[no sievers, 2014/01/13 23:46:40]

Hmm... is that the right check? Aren't you trying to figure out whether this is
a conditional binding or not, which could have only one name?

[oetuaho-nv, 2014/01/14 16:39:58]

The bindings only guarantee that the correct version of a function will be bound
if it is available. If a function only has one name, the safest way to achieve
this is to try bind it regardless of where the function should be available or
not. The higher levels of the code have the responsibility to determine which
functions to actually use. The commit message and the comment at the top of the
file try to explain this as well.

Eventually, it might be good if the higher levels could check whether a function
is usable just by checking if it's bound to null, but it takes a lot of work
with the GL specs and testing with different platforms to get there. My opinion
is that this work should be split into multiple patches, instead of trying to
roll it into this one patch that has already been in review for 5 weeks.

[no sievers, 2014/01/14 23:16:01]

Why not check the extension? That seems like the right way to see if a function
is available and already works.

I don't think we have to worry about the case where the extension is advertised
and the entry points are not available or broken for some reason. That sounds
like a really broken implementation.

Can't we use the 'NotBound' stub rather than dropping version conditions of the
last version?

[oetuaho-nv, 2014/01/15 15:50:24]

The risk doesn't result only from broken driver implementations, but rather that
all the conditions for binding a function need to be 100% correct if they are
always enforced. The most common problematic case is that the same function is
defined in an ARB extension and also in core in a later version. In this case it
needs to be explicitly specified like this:

'versions': [{ 'name': 'glFoo', 'gl_version': '4.0'},
             { 'name': 'glFoo', 'extensions': ['GL_ARB_FOO']}]

Otherwise the code will just automatically make the ARB extension a condition
for binding the function based on the extension headers, which will probably
usually work, but there could be a spec-conformant GL implementation where this
doesn't work, and if it exists it's probably exotic enough that it doesn't come
up in testing. So I'd prefer that this work would be done in smaller, more
manageable pieces, instead of needing to go through all the GL specs ever
published at once to check for cases like this.

It's also a small additional risk if functions are moved from
InitializeStaticBindings to InitializeDynamicBindings, mostly on Windows where
the OpenGL initialization is broken and we can't properly test this, but where
we should still avoid additional regressions. You yourself were worried about
functions being called before a context is made current and the dynamic bindings
are initialized in an earlier review on 2013/12/05.

[no sievers, 2014/01/15 21:03:28]

Actually I was more worried about the case where we specify the last version
with an explicit condition (for example glDiscardFramebufferEXT()), where it
seemed weird that we just drop that condition.

But fair enough :)

+      WriteFuncBinding(file, func['known_as'], func['known_as'])
+    else:
+      file.write('  fn.%sFn = reinterpret_cast<%sProc>(%sNotBound);\n' %
+          (func['known_as'], func['known_as'], func['known_as']))
+
   file.write('}\n')
   file.write('\n')
 
-  # Write function to initialize the extension function pointers. This function
-  # uses a current context to query which extensions are actually supported.
-  file.write("""void Driver%s::InitializeExtensionBindings(
-    GLContext* context) {
+  # Write function to initialize bindings where choice of the function depends
+  # on the extension string or the GL version.
+  file.write("""void Driver%s::InitializeDynamicBindings(GLContext* context) {
+  DCHECK(context && context->IsCurrent(NULL));
+  const GLVersionInfo* ver ALLOW_UNUSED = context->GetVersionInfo();
+  std::string extensions ALLOW_UNUSED = context->GetExtensions();
+  extensions += " ";
+
 """ % set_name.upper())
-  file.write('  DCHECK(context && context->IsCurrent(NULL));\n')
-  for extension, ext_functions in used_extension_functions:
-    file.write('  ext.b_%s = context->HasExtension("%s");\n' %
+  for extension in 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))
-    file.write('  if (ext.b_%s) {\n' %
-        (extension))
-    queried_entry_points = set()
-    for entry_point_name, function_name in ext_functions:
-      # Replace the pointer unconditionally unless this extension has several
-      # alternatives for the same entry point (e.g.,
-      # GL_ARB_blend_func_extended).
-      if entry_point_name in queried_entry_points:
-        file.write('    if (!fn.%sFn)\n  ' % entry_point_name)
-      file.write(
-         '    fn.%sFn = reinterpret_cast<%sProc>(GetGLProcAddress("%s"));\n' %
-             (entry_point_name, entry_point_name, function_name))
-      queried_entry_points.add(entry_point_name)
-    file.write('  }\n')
+
+  def VersionCondition(version):
+    conditions = []
+    if 'gl_versions' in version:
+      gl_versions = version['gl_versions']
+      version_cond = ' || '.join(['ver->is_%s' % gl for gl in gl_versions])
+      conditions.append(version_cond)
+    ext = []
+    if 'extension' in version:
+      ext.append(version['extension'])
+    if 'extensions' in version:
+      ext.extend([e for e in version['extensions'] if e not in ext])
+    if ext:
+      ext_cond = ' || '.join(['ext.b_%s' % e for e in ext])
+      conditions.append(ext_cond)
+    def Wrap(cond):

[no sievers, 2014/01/13 23:46:40]

nit: Maybe this function can be written slightly more readable by having
|version_condition| and |ext_condition| and simply returning
'(version_condition) && (ext_condition)'.

[oetuaho-nv, 2014/01/14 16:39:58]

Either of the conditions might be empty, so simply returning version_condition
&& ext_condition doesn't work. We might initialize the values to true, but I
don't think we want a lot of '&& true' in the generated code either.

Wrapping the conditions to parentheses could be unconditional, and I used to
have it this way at first, but that resulted in a lot of extra parentheses in
the generated code, which made it hard to follow.

I think the best way to go is to get rid of the list comprehension, which makes
the join line simpler, and use the Wrap function for version_cond and ext_cond
separately. I'll also rename the two different Wrap functions to WrapOr and
WrapAnd to eliminate some confusion.

+      if ' || ' in cond:
+        return '(%s)' % cond
+      return cond
+    return ' && '.join([Wrap(cond) for cond in conditions])
+
+  def WriteConditionalFuncBinding(file, func):
+    assert len(func['versions']) > 1

[no sievers, 2014/01/13 23:46:40]

Why? What if there was a GLES2-only function that I wanted to bind conditionally
(only on GLES2 platforms)?

[oetuaho-nv, 2014/01/14 16:39:58]

I believe my answer above covers this - the philosophy is to bind functions
conditionally only if it is necessary for choosing the correct function.

+    known_as = func['known_as']
+    i = 0
+    first_version = True
+    while i < len(func['versions']):
+      version = func['versions'][i]
+      cond = VersionCondition(version)

[no sievers, 2014/01/13 23:46:40]

I find the condition combining hard to read and it also seems to generate
different code depending on order of the 'versions' list (for example 3 versions
with names 'glFoo', 'glFooOES', 'glFoo' vs. 'glFoo', 'glFoo', 'glFooOES').

Is it really necessary or could it just be left out? It looks to me like it just
generates 'if (a || b) BindFunc' instead of two if-statements therefore avoiding
assigning the value twice in the (somewhat unexpected?) case of multiple version
conditions both resolving to true on a given platform.

[oetuaho-nv, 2014/01/14 16:39:58]

You're right about the combining depending on the order of the versions list,
but I don't think that is a problem. The order of the versions list determines
which version is preferred. You can't combine the conditions of glFoo (1) and
glFoo (2), in case binding glFooOES is preferred less than glFoo (1) but
preferred more than glFoo (2).

Combining conditions is here in the first place to make the generated code easy
to follow. Without it, there could be nonsensical generated code such as first
binding the function conditionally and then binding it unconditionally. This
way, if there's a bug concerning a specific function - such as the bug with
glDiscardFramebufferEXT that this patch fixes - it's easier to check if the
bindings are correct.

+      combined_conditions = [cond]
+      while i + 1 < len(func['versions']) and \
+          func['versions'][i + 1]['name'] == version['name']:
+        i += 1
+        combined_conditions.append(VersionCondition(func['versions'][i]))
+      if len(combined_conditions) > 1:
+        if [1 for cond in combined_conditions if cond == '']:
+          cond = ''
+        else:
+          def Wrap(cond):
+            if ' && ' in cond:
+              return '(%s)' % cond
+            return cond
+          cond = ' || '.join([Wrap(cond) for cond in combined_conditions])
+      # Don't make the last possible binding conditional on anything else but
+      # that the function isn't already bound to avoid verbose specification
+      # of functions which have both ARB and core versions with the same name,
+      # and to be able to bind to mock extension functions in unit tests which
+      # call InitializeDynamicGLBindings with a stub context that doesn't have
+      # extensions in its extension string.
+      # TODO(oetuaho@nvidia.com): Get rid of the fallback.
+      # http://crbug.com/325668
+      if cond != '' and i + 1 < len(func['versions']):

[no sievers, 2014/01/13 23:46:40]

nit: Can you create a Boolean |last_version| for 'i == len(func['versions']' for
readability in this condition? (You are using it above also.)

[oetuaho-nv, 2014/01/14 16:39:58]

Done.

+        if not first_version:
+          file.write('  if (!fn.%sFn && (%s))\n  ' % (known_as, cond))
+        else:
+          file.write('  if (%s)\n  ' % cond)
+      elif not first_version:
+        file.write('  if (!fn.%sFn)\n  ' % known_as)
+      WriteFuncBinding(file, known_as, version['name'])
+      i += 1
+      first_version = False
+
+  for func in functions:
+    if len(func['names']) > 1:
+      file.write('\n')
+      file.write('  fn.%sFn = 0;\n' % func['known_as'])
+      file.write('  debug_fn.%sFn = 0;\n' % func['known_as'])
+      WriteConditionalFuncBinding(file, func)
+
+  # Some new function pointers have been added, so update them in debug bindings
+  file.write('\n')
   file.write('  if (g_debugBindingsInitialized)\n')
-  file.write('    UpdateDebugExtensionBindings();\n')
+  file.write('    InitializeDebugBindings();\n')
   file.write('}\n')
   file.write('\n')
 
   # Write empty stubs for functions that want one.
   file.write('extern "C" {\n')
   for func in nulldraw_functions:
-    names = func['names']
+    known_as = func['known_as']
     return_type = func['return_type']
     arguments = func['arguments']
     file.write('\n')
     file.write('static %s GL_BINDING_CALL Stub_%s(%s) {}\n' %
-        (return_type, names[0], arguments))
+        (return_type, known_as, arguments))
   file.write('}  // extern "C"\n')
 
   # Write logging wrappers for each function.
   file.write('extern "C" {\n')
   for func in functions:
-    names = func['names']
     return_type = func['return_type']
     arguments = func['arguments']
     file.write('\n')
     file.write('static %s GL_BINDING_CALL Debug_%s(%s) {\n' %
-        (return_type, names[0], arguments))
+        (return_type, func['known_as'], arguments))
     argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', arguments)
     argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', argument_names)
     log_argument_names = re.sub(
         r'const char\* ([a-zA-Z0-9_]+)', r'CONSTCHAR_\1', arguments)
     log_argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\* ([a-zA-Z0-9_]+)',
         r'CONSTVOID_\2', log_argument_names)
     log_argument_names = re.sub(
         r'(?<!E)GLenum ([a-zA-Z0-9_]+)', r'GLenum_\1', log_argument_names)
     log_argument_names = re.sub(
         r'(?<!E)GLboolean ([a-zA-Z0-9_]+)', r'GLboolean_\1', log_argument_names)
     log_argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2',
         log_argument_names)
     log_argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2',
         log_argument_names)
     log_argument_names = re.sub(
         r'CONSTVOID_([a-zA-Z0-9_]+)',
-        r'static_cast<const void*>(\1)', log_argument_names);
+        r'static_cast<const void*>(\1)', log_argument_names)
     log_argument_names = re.sub(
-        r'CONSTCHAR_([a-zA-Z0-9_]+)', r'\1', log_argument_names);
+        r'CONSTCHAR_([a-zA-Z0-9_]+)', r'\1', log_argument_names)
     log_argument_names = re.sub(
         r'GLenum_([a-zA-Z0-9_]+)', r'GLES2Util::GetStringEnum(\1)',
         log_argument_names)
     log_argument_names = re.sub(
         r'GLboolean_([a-zA-Z0-9_]+)', r'GLES2Util::GetStringBool(\1)',
         log_argument_names)
     log_argument_names = log_argument_names.replace(',', ' << ", " <<')
     if argument_names == 'void' or argument_names == '':
       argument_names = ''
       log_argument_names = ''
     else:
       log_argument_names = " << " + log_argument_names
-    function_name = names[0]
+    function_name = func['known_as']
     if return_type == 'void':
       file.write('  GL_SERVICE_LOG("%s" << "(" %s << ")");\n' %
           (function_name, log_argument_names))
       file.write('  g_driver_%s.debug_fn.%sFn(%s);\n' %
           (set_name.lower(), function_name, argument_names))
       if 'logging_code' in func:
         file.write("%s\n" % func['logging_code'])
     else:
       file.write('  GL_SERVICE_LOG("%s" << "(" %s << ")");\n' %
           (function_name, log_argument_names))
       file.write('  %s result = g_driver_%s.debug_fn.%sFn(%s);\n' %
           (return_type, set_name.lower(), function_name, argument_names))
       if 'logging_code' in func:
         file.write("%s\n" % func['logging_code'])
       else:
-        file.write('  GL_SERVICE_LOG("GL_RESULT: " << result);\n');
+        file.write('  GL_SERVICE_LOG("GL_RESULT: " << result);\n')
       file.write('  return result;\n')
     file.write('}\n')
   file.write('}  // extern "C"\n')
 
   # Write function to initialize the debug function pointers.
   file.write('\n')
   file.write('void Driver%s::InitializeDebugBindings() {\n' %
              set_name.upper())
   for func in functions:
-    first_name = func['names'][0]
+    first_name = func['known_as']
     file.write('  if (!debug_fn.%sFn) {\n' % first_name)
     file.write('    debug_fn.%sFn = fn.%sFn;\n' % (first_name, first_name))
     file.write('    fn.%sFn = Debug_%s;\n' % (first_name, first_name))
     file.write('  }\n')
   file.write('  g_debugBindingsInitialized = true;\n')
   file.write('}\n')
 
   # Write function to initialize the nulldraw function pointers.
   if nulldraw_functions:
     file.write('\n')
     file.write('void Driver%s::InitializeNullDrawBindings() {\n' %
                set_name.upper())
 
     for func in nulldraw_functions:
-      first_name = func['names'][0]
+      first_name = func['known_as']
       file.write('  fn.%sFn = Stub_%s;\n' % (first_name, first_name))
     file.write('}\n')
 
-  # Write function to update the debug function pointers to extension functions
-  # after the extensions have been initialized.
-  file.write('\n')
-  file.write('void Driver%s::UpdateDebugExtensionBindings() {\n' %
-             set_name.upper())
-  for extension, ext_functions in used_extension_functions:
-    for name, _ in ext_functions:
-      file.write('  if (debug_fn.%sFn != fn.%sFn &&\n' % (name, name))
-      file.write('      fn.%sFn != Debug_%s) {\n' % (name, name))
-      file.write('    debug_fn.%sFn = fn.%sFn;\n' % (name, name))
-      file.write('    fn.%sFn = Debug_%s;\n' % (name, name))
-      file.write('  }\n')
-  file.write('}\n')
-
   # Write function to clear all function pointers.
   file.write('\n')
   file.write("""void Driver%s::ClearBindings() {
   memset(this, 0, sizeof(*this));
 }
 """ % set_name.upper())
 
   # Write GLApiBase functions
   for func in functions:
-    names = func['names']
     return_type = func['return_type']
     arguments = func['arguments']
     file.write('\n')
     file.write('%s %sApiBase::%sFn(%s) {\n' %
-        (return_type, set_name.upper(), names[0], arguments))
+        (return_type, set_name.upper(), func['known_as'], arguments))
     argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', arguments)
     argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', argument_names)
     if argument_names == 'void' or argument_names == '':
       argument_names = ''
-    function_name = names[0]
+    function_name = func['known_as']
     if return_type == 'void':
       file.write('  driver_->fn.%sFn(%s);\n' %
           (function_name, argument_names))
     else:
       file.write('  return driver_->fn.%sFn(%s);\n' %
           (function_name, argument_names))
     file.write('}\n')
 
   # Write TraceGLApi functions
   for func in functions:
-    names = func['names']
     return_type = func['return_type']
     arguments = func['arguments']
     file.write('\n')
     file.write('%s Trace%sApi::%sFn(%s) {\n' %
-        (return_type, set_name.upper(), names[0], arguments))
+        (return_type, set_name.upper(), func['known_as'], arguments))
     argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', arguments)
     argument_names = re.sub(
         r'(const )?[a-zA-Z0-9_]+\** ([a-zA-Z0-9_]+)', r'\2', argument_names)
     if argument_names == 'void' or argument_names == '':
       argument_names = ''
-    function_name = names[0]
+    function_name = func['known_as']
     file.write('  TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::%s")\n' %
                function_name)
     if return_type == 'void':
       file.write('  %s_api_->%sFn(%s);\n' %
           (set_name.lower(), function_name, argument_names))
     else:
       file.write('  return %s_api_->%sFn(%s);\n' %
           (set_name.lower(), function_name, argument_names))
     file.write('}\n')
 
@@ skipping 14 matching lines @@
 #include <string.h>
 
 #include "ui/gl/gl_interface.h"
 
 namespace gfx {
 """)
   # Write function that trampoline into the GLInterface.
   for func in functions:
     file.write('\n')
     file.write('%s GL_BINDING_CALL Mock_%s(%s) {\n' %
-        (func['return_type'], func['names'][0], func['arguments']))
-    argument_names = re.sub(r'(const )?[a-zA-Z0-9]+((\s*const\s*)?\*)* ([a-zA-Z0-9]+)', r'\4',
-                              func['arguments'])
+        (func['return_type'], func['known_as'], func['arguments']))
+    arg_re = r'(const )?[a-zA-Z0-9]+((\s*const\s*)?\*)* ([a-zA-Z0-9]+)'
+    argument_names = re.sub(arg_re, r'\4', func['arguments'])
     if argument_names == 'void':
       argument_names = ''
-    function_name = func['names'][0][2:]
+    function_name = func['known_as'][2:]
     if func['return_type'] == 'void':
       file.write('  GLInterface::GetGLInterface()->%s(%s);\n' %
           (function_name, argument_names))
     else:
       file.write('  return GLInterface::GetGLInterface()->%s(%s);\n' %
           (function_name, argument_names))
     file.write('}\n')
 
   # Write an 'invalid' function to catch code calling through uninitialized
   # function pointers or trying to interpret the return value of
   # GLProcAddress().
   file.write('\n')
   file.write('static void MockInvalidFunction() {\n')
   file.write('  NOTREACHED();\n')
   file.write('}\n')
 
   # Write a function to lookup a mock GL function based on its name.
   file.write('\n')
   file.write('void* GL_BINDING_CALL GetMockGLProcAddress(const char* name) {\n')
   for func in functions:
-    first_name = func['names'][0]
-    file.write('  if (strcmp(name, "%s") == 0)\n' % first_name)
-    file.write('    return reinterpret_cast<void*>(Mock_%s);\n' % first_name)
+    for name in func['names']:
+      file.write('  if (strcmp(name, "%s") == 0)\n' % name)
+      file.write(
+          '    return reinterpret_cast<void*>(Mock_%s);\n' % func['known_as'])
   # Always return a non-NULL pointer like some EGL implementations do.
   file.write('  return reinterpret_cast<void*>(&MockInvalidFunction);\n')
-  file.write('}\n');
+  file.write('}\n')
 
   file.write('\n')
   file.write('}  // namespace gfx\n')
 
 
 def ParseExtensionFunctionsFromHeader(header_file):
   """Parse a C extension header file and return a map from extension names to
   a list of functions.
 
   Args:
@@ skipping 62 matching lines @@
   return function_to_extensions
 
 
 def LooksLikeExtensionFunction(function):
   """Heuristic to see if a function name is consistent with extension function
   naming."""
   vendor = re.match(r'\w+?([A-Z][A-Z]+)$', function)
   return vendor is not None and not vendor.group(1) in ['GL', 'API', 'DC']
 
 
-def GetUsedExtensionFunctions(functions, extension_headers, extra_extensions):
-  """Determine which functions belong to extensions.
+def FillExtensionsFromHeaders(functions, extension_headers, extra_extensions):
+  """Determine which functions belong to extensions based on extension headers,
+  and fill in this information to the functions table for functions that don't
+  already have the information.
 
   Args:
-    functions: List of (return type, function names, arguments).
+    functions: List of (return type, function versions, arguments).
     extension_headers: List of header file names.
+    extra_extensions: Extensions to add to the list.
   Returns:
-    List of (extension name, [function name alternatives]) sorted with least
-    preferred extensions first.
+    List of used extensions.
   """
   # Parse known extensions.
   extensions = GetExtensionFunctions(extension_headers)
   functions_to_extensions = GetFunctionToExtensionMap(extensions)
 
-  # Collect all used extension functions.
-  used_extension_functions = collections.defaultdict(lambda: [])
+  # Fill in the extension information.
+  used_extensions = []
   for func in functions:
-    for name in func['names']:
-      # Make sure we know about all extension functions.
-      if (LooksLikeExtensionFunction(name) and
-          not name in functions_to_extensions):
+    for version in func['versions']:
+      name = version['name']
+      # Make sure we know about all extensions and extension functions.
+      if 'extension' in version:
+        if version['extension'] not in used_extensions:
+          used_extensions.append(version['extension'])
+      elif 'extensions' in version:
+        used_extensions.extend(
+            [e for e in version['extensions'] if e not in used_extensions])
+      elif name in functions_to_extensions:
+        # If there are multiple versions with the same name, assume that they
+        # already have all the correct conditions, we can't just blindly add
+        # the same extension conditions to all of them
+        if len([v for v in func['versions'] if v['name'] == name]) == 1:
+          version['extensions'] = functions_to_extensions[name]
+          used_extensions.extend(
+              [e for e in version['extensions'] if e not in used_extensions])
+      elif LooksLikeExtensionFunction(name):
         raise RuntimeError('%s looks like an extension function but does not '
             'belong to any of the known extensions.' % name)
-      if name in functions_to_extensions:
-        extensions = functions_to_extensions[name][:]
-        if 'other_extensions' in func:
-          extensions.extend(func['other_extensions'])
-        for extension in extensions:
-          used_extension_functions[extension].append((func['names'][0], name))
 
   # Add extensions that do not have any functions.
-  used_extension_functions.update(dict(
-      [(e, []) for e in extra_extensions if e not in used_extension_functions]))
+  used_extensions.extend(
+      [e for e in extra_extensions if e not in used_extensions])
 
-  def ExtensionSortKey(name):
-    # Prefer ratified extensions and EXTs.
-    preferences = ['_ARB_', '_OES_', '_EXT_', '']
-    for i, category in enumerate(preferences):
-      if category in name:
-        return -i
-  used_extension_functions = sorted(used_extension_functions.items(),
-      key = lambda item: ExtensionSortKey(item[0]))
-  return used_extension_functions
+  return used_extensions
 
 
 def ResolveHeader(header, header_paths):
   paths = header_paths.split(':')
 
   # Always use a path for Chromium-specific extensions. They are extracted
   # to separate files.
   paths.append('.')
   paths.append('../../gpu')
 
@@ skipping 19 matching lines @@
   parser.add_option('--header-paths')
 
   options, args = parser.parse_args(argv)
 
   if options.inputs:
     for [_, _, _, headers, _] in FUNCTION_SETS:
       for header in headers:
         print ResolveHeader(header, options.header_paths)
     return 0
 
+  directory = '.'
   if len(args) >= 1:
-    dir = args[0]
-  else:
-    dir = '.'
+    directory = args[0]
 
   for [functions,
        nulldraw_functions,
        set_name,
        extension_headers,
        extensions] in FUNCTION_SETS:
+    # Function names can be specified in two ways (list of unique names or list
+    # of versions with different binding conditions), fill in the data both
+    # ways:
+    for func in functions + nulldraw_functions:
+      assert 'versions' in func or 'names' in func, 'Function with no names'
+      if 'versions' not in func:
+        func['versions'] = [{'name': n} for n in func['names']]
+      if 'names' not in func:
+        func['names'] = []
+        for version in func['versions']:
+          if version['name'] not in func['names']:
+            func['names'].append(version['name'])

[no sievers, 2014/01/13 23:46:40]

Why do we need both func['names'] and func['versions'] rather than just using,
let's say, func['versions'] from here on?

[oetuaho-nv, 2014/01/14 16:39:58]

The set of unique names is needed on a few occasions, and there it was easier to
refer to func['names'] than set([version['name'] for version in
func['versions']]) which will also lose the ordering. However, it seems like
having a list of unique names with the order preserved is not necessary, and I
understand this might be a source of confusion. I'll change it so that only
'versions' is used from here on.

+      # Use the first version's name unless otherwise specified
+      if 'known_as' not in func:
+        func['known_as'] = func['names'][0]
+
     extension_headers = [ResolveHeader(h, options.header_paths)
                          for h in extension_headers]
-    used_extension_functions = GetUsedExtensionFunctions(
+    used_extensions = FillExtensionsFromHeaders(
         functions, extension_headers, extensions)
 
     header_file = open(
-        os.path.join(dir, 'gl_bindings_autogen_%s.h' % set_name), 'wb')
-    GenerateHeader(header_file, functions, set_name, used_extension_functions)
+        os.path.join(directory, 'gl_bindings_autogen_%s.h' % set_name), 'wb')
+    GenerateHeader(header_file, functions, set_name, used_extensions)
     header_file.close()
 
     header_file = open(
-        os.path.join(dir, 'gl_bindings_api_autogen_%s.h' % set_name), 'wb')
-    GenerateAPIHeader(
-        header_file, functions, set_name, used_extension_functions)
+        os.path.join(directory, 'gl_bindings_api_autogen_%s.h' % set_name),
+        'wb')
+    GenerateAPIHeader(header_file, functions, set_name)
     header_file.close()
 
     source_file = open(
-        os.path.join(dir, 'gl_bindings_autogen_%s.cc' % set_name), 'wb')
+        os.path.join(directory, 'gl_bindings_autogen_%s.cc' % set_name), 'wb')
     GenerateSource(source_file,
                    functions,
                    nulldraw_functions,
                    set_name,
-                   used_extension_functions)
+                   used_extensions)
     source_file.close()
 
     header_file = open(
-        os.path.join(dir, 'gl_interface_autogen_%s.h' % set_name), 'wb')
-    GenerateInterfaceHeader(
-        header_file, functions, set_name, used_extension_functions)
+        os.path.join(directory, 'gl_interface_autogen_%s.h' % set_name), 'wb')
+    GenerateInterfaceHeader(header_file, functions, set_name)
     header_file.close()
 
     header_file = open(
-        os.path.join(dir, 'gl_mock_autogen_%s.h' % set_name), 'wb')
-    GenerateMockHeader(
-        header_file, functions, set_name, used_extension_functions)
+        os.path.join(directory, 'gl_mock_autogen_%s.h' % set_name), 'wb')
+    GenerateMockHeader(header_file, functions, set_name)
     header_file.close()
 
-  source_file = open(os.path.join(dir, 'gl_bindings_autogen_mock.cc'), 'wb')
+  source_file = open(os.path.join(directory, 'gl_bindings_autogen_mock.cc'),
+                     'wb')
   GenerateMockSource(source_file, GL_FUNCTIONS)
   source_file.close()
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))