Update from https://crrev.com/312398

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
+
+HEADER_PATHS = [
+  '../../third_party/khronos',
+  '../../third_party/mesa/src/include',
+  '.',
+  '../../gpu',
+]
 
 """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:
@@ skipping 119 matching lines @@
       'GLenum target, GLsizeiptr size, const void* data, GLenum usage', },
 { 'return_type': 'void',
   'names': ['glBufferSubData'],
   'arguments':
       'GLenum target, GLintptr offset, GLsizeiptr size, const void* data', },
 { 'return_type': 'GLenum',
   'names': ['glCheckFramebufferStatusEXT',
             'glCheckFramebufferStatus'],
   'arguments': 'GLenum target',
   'logging_code': """
-  GL_SERVICE_LOG("GL_RESULT: " << GLES2Util::GetStringEnum(result));
+  GL_SERVICE_LOG("GL_RESULT: " << GLEnums::GetStringEnum(result));
 """, },
 { 'return_type': 'void',
   'names': ['glClear'],
   'arguments': 'GLbitfield mask', },
 { 'return_type': 'void',
   'versions': [{ 'name': 'glClearBufferfi',
                  'gl_versions': ['gl3', 'gl4', 'es3'] }],
   'arguments': 'GLenum buffer, GLint drawbuffer, const GLfloat depth, '
                'GLint stencil', },
 { 'return_type': 'void',
@@ skipping 351 matching lines @@
 { 'return_type': 'void',
   'names': ['glGetBooleanv'],
   'arguments': 'GLenum pname, GLboolean* params', },
 { 'return_type': 'void',
   'names': ['glGetBufferParameteriv'],
   'arguments': 'GLenum target, GLenum pname, GLint* params', },
 { 'return_type': 'GLenum',
   'names': ['glGetError'],
   'arguments': 'void',
   'logging_code': """
-  GL_SERVICE_LOG("GL_RESULT: " << GLES2Util::GetStringError(result));
+  GL_SERVICE_LOG("GL_RESULT: " << GLEnums::GetStringError(result));
 """, },
 { 'return_type': 'void',
   'names': ['glGetFenceivNV'],
   'arguments': 'GLuint fence, GLenum pname, GLint* params', },
 { 'return_type': 'void',
   'names': ['glGetFloatv'],
   'arguments': 'GLenum pname, GLfloat* params', },
 { 'return_type': 'GLint',
   'versions': [{ 'name': 'glGetFragDataLocation',
                  'gl_versions': ['gl3', 'gl4', 'es3'] }],
@@ skipping 1146 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'], []],
 ]
 
+GLES2_HEADERS_WITH_ENUMS = [
+  'GLES2/gl2.h',
+  'GLES2/gl2ext.h',
+  'GLES2/gl2chromium.h',
+  'GLES2/gl2extchromium.h',
+  'GLES3/gl3.h',
+]
+
+SELF_LOCATION = os.path.dirname(os.path.abspath(__file__))
+
+LICENSE_AND_HEADER = """\
+// Copyright 2014 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 auto-generated from
+// ui/gl/generate_bindings.py
+// It's formatted by clang-format using chromium coding style:
+//    clang-format -i -style=chromium filename
+// DO NOT EDIT!
+
+"""
 
 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.
+  file.write(LICENSE_AND_HEADER +
+"""
 
 #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()})
 
@@ skipping 44 matching lines @@
 
   file.write('\n')
   file.write('#endif  //  UI_GFX_GL_GL_BINDINGS_AUTOGEN_%s_H_\n' %
       set_name.upper())
 
 
 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()})
+  file.write(LICENSE_AND_HEADER)
 
   # Write API declaration.
   for func in functions:
     file.write('  %s %sFn(%s) override;\n' %
       (func['return_type'], func['known_as'], func['arguments']))
 
   file.write('\n')
 
 
 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()})
+  file.write(LICENSE_AND_HEADER)
 
   # 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['known_as'][2:], func['return_type'], args))
 
   file.write('\n')
 
 
 def GenerateSource(file, functions, set_name, used_extensions):
   """Generates gl_bindings_autogen_x.cc"""
 
+  set_header_name = "ui/gl/gl_" + set_name.lower() + "_api_implementation.h"
+  include_list = [ 'base/debug/trace_event.h',
+                   'ui/gl/gl_enums.h',
+                   'ui/gl/gl_bindings.h',
+                   'ui/gl/gl_context.h',
+                   'ui/gl/gl_implementation.h',
+                   'ui/gl/gl_version_info.h',
+                   set_header_name ]
+  includes_string = "\n".join(["#include \"{0}\"".format(h)
+                               for h in sorted(include_list)])
+
   # 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.
+  file.write(LICENSE_AND_HEADER +
+"""
 
 #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;
+%s
 
 namespace gfx {
-""" % set_name.lower())
+""" % includes_string)
 
   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 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')
@@ skipping 94 matching lines @@
       # 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 not last_version:
         if not first_version:
-          file.write('  if (!fn.%sFn && (%s))\n  ' % (known_as, cond))
+          file.write('  if (!fn.%sFn && (%s)) {\n  ' % (known_as, cond))
         else:
-          file.write('  if (%s)\n  ' % cond)
+          file.write('  if (%s) {\n  ' % cond)
       elif not first_version:
-        file.write('  if (!fn.%sFn)\n  ' % known_as)
+        file.write('  if (!fn.%sFn) {\n  ' % known_as)
       WriteFuncBinding(file, known_as, version['name'])
+      file.write('}\n')
       i += 1
       first_version = False
 
   for func in functions:
     unique_names = set([version['name'] for version in func['versions']])
     if len(unique_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)
@@ skipping 31 matching lines @@
         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)
     log_argument_names = re.sub(
         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)',
+        r'GLenum_([a-zA-Z0-9_]+)', r'GLEnums::GetStringEnum(\1)',
         log_argument_names)
     log_argument_names = re.sub(
-        r'GLboolean_([a-zA-Z0-9_]+)', r'GLES2Util::GetStringBool(\1)',
+        r'GLboolean_([a-zA-Z0-9_]+)', r'GLEnums::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 = func['known_as']
     if return_type == 'void':
       file.write('  GL_SERVICE_LOG("%s" << "(" %s << ")");\n' %
@@ skipping 125 matching lines @@
         'return_type': func['return_type'],
         'arguments': func['arguments'],
         'known_as': func['known_as']
       })
   return uniquely_named_functions
 
 
 def GenerateMockBindingsHeader(file, functions):
   """Headers for functions that invoke MockGLInterface members"""
 
-  file.write(
-"""// Copyright (c) 2014 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.
-
-""")
+  file.write(LICENSE_AND_HEADER)
   uniquely_named_functions = GetUniquelyNamedFunctions(functions)
 
   for key in sorted(uniquely_named_functions.iterkeys()):
     func = uniquely_named_functions[key]
     file.write('static %s GL_BINDING_CALL Mock_%s(%s);\n' %
         (func['return_type'], func['name'], func['arguments']))
 
 
 def GenerateMockBindingsSource(file, functions):
   """Generates functions that invoke MockGLInterface members and a
   GetGLProcAddress function that returns addresses to those functions."""
 
-  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.
+  file.write(LICENSE_AND_HEADER +
+"""
 
 #include <string.h>
 
 #include "ui/gl/gl_mock.h"
 
 namespace gfx {
 
 // This is called mainly to prevent the compiler combining the code of mock
 // functions with identical contents, so that their function pointers will be
 // different.
@@ skipping 41 matching lines @@
     name = uniquely_named_functions[key]['name']
     file.write('  if (strcmp(name, "%s") == 0)\n' % name)
     file.write('    return reinterpret_cast<void*>(Mock_%s);\n' % name)
   # 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('}  // namespace gfx\n')
 
+def GenerateEnumUtils(out_file, input_filenames):
+  enum_re = re.compile(r'\#define\s+(GL_[a-zA-Z0-9_]+)\s+([0-9A-Fa-fx]+)')
+  dict = {}
+  for fname in input_filenames:
+    lines = open(fname).readlines()
+    for line in lines:
+      m = enum_re.match(line)
+      if m:
+        name = m.group(1)
+        value = m.group(2)
+        if len(value) <= 10:
+          if not value in dict:
+            dict[value] = name
+          # check our own _CHROMIUM macro conflicts with khronos GL headers.
+          elif dict[value] != name and (name.endswith('_CHROMIUM') or
+              dict[value].endswith('_CHROMIUM')):
+            raise RunTimeError("code collision: %s and %s have the same code %s"
+                               %  (dict[value], name, value))
+
+  out_file.write(LICENSE_AND_HEADER)
+  out_file.write("static const GLEnums::EnumToString "
+                 "enum_to_string_table[] = {\n")
+  for value in dict:
+    out_file.write('  { %s, "%s", },\n' % (value, dict[value]))
+  out_file.write("""};
+
+const GLEnums::EnumToString* const GLEnums::enum_to_string_table_ =
+  enum_to_string_table;
+const size_t GLEnums::enum_to_string_table_len_ =
+  sizeof(enum_to_string_table) / sizeof(enum_to_string_table[0]);
+
+""")
+
 
 def ParseExtensionFunctionsFromHeader(header_file):
   """Parse a C extension header file and return a map from extension names to
   a list of functions.
 
   Args:
     header_file: Line-iterable C header file.
   Returns:
     Map of extension name => functions.
   """
@@ skipping 100 matching lines @@
         raise RuntimeError('%s looks like an extension function but does not '
             'belong to any of the known extensions.' % name)
 
   # Add extensions that do not have any functions.
   used_extensions.update(extra_extensions)
 
   return used_extensions
 
 
 def ResolveHeader(header, header_paths):
-  paths = header_paths.split(':')
-
-  for path in paths:
+  for path in header_paths:
     result = os.path.join(path, header)
     if not os.path.isabs(path):
-      result = os.path.relpath(os.path.join(os.getcwd(), result), os.getcwd())
+      result = os.path.abspath(os.path.join(SELF_LOCATION, result))
     if os.path.exists(result):
       # Always use forward slashes as path separators. Otherwise backslashes
       # may be incorrectly interpreted as escape characters.
       return result.replace(os.path.sep, '/')
 
   raise Exception('Header %s not found.' % header)
 
 
 def main(argv):
   """This is the main function."""
 
   parser = optparse.OptionParser()
   parser.add_option('--inputs', action='store_true')
-  parser.add_option('--header-paths')
   parser.add_option('--verify-order', action='store_true')
 
   options, args = parser.parse_args(argv)
 
   if options.inputs:
     for [_, _, headers, _] in FUNCTION_SETS:
       for header in headers:
-        print ResolveHeader(header, options.header_paths)
+        print ResolveHeader(header, HEADER_PATHS)
     return 0
 
-  directory = '.'
+  directory = SELF_LOCATION
   if len(args) >= 1:
     directory = args[0]
 
+  def ClangFormat(filename):
+    formatter = "clang-format"
+    if platform.system() == "Windows":
+      formatter += ".bat"
+    call([formatter, "-i", "-style=chromium", filename])
+
   for [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 to the
     # versions list in case it is missing, so that can be used from here on:
     for func in 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']]
       # Use the first version's name unless otherwise specified
       if 'known_as' not in func:
         func['known_as'] = func['versions'][0]['name']
       # Make sure that 'names' is not accidentally used instead of 'versions'
       if 'names' in func:
         del func['names']
 
     # Check function names in each set is sorted in alphabetical order.
     for index in range(len(functions) - 1):
       func_name = functions[index]['known_as']
       next_func_name = functions[index + 1]['known_as']
       if func_name.lower() > next_func_name.lower():
         raise Exception(
             'function %s is not in alphabetical order' % next_func_name)
     if options.verify_order:
       continue
 
-    extension_headers = [ResolveHeader(h, options.header_paths)
+    extension_headers = [ResolveHeader(h, HEADER_PATHS)
                          for h in extension_headers]
     used_extensions = FillExtensionsFromHeaders(
         functions, extension_headers, extensions)
 
     header_file = open(
         os.path.join(directory, 'gl_bindings_autogen_%s.h' % set_name), 'wb')
     GenerateHeader(header_file, functions, set_name, used_extensions)
     header_file.close()
+    ClangFormat(header_file.name)
 
     header_file = open(
         os.path.join(directory, 'gl_bindings_api_autogen_%s.h' % set_name),
         'wb')
     GenerateAPIHeader(header_file, functions, set_name)
     header_file.close()
+    ClangFormat(header_file.name)
 
     source_file = open(
         os.path.join(directory, 'gl_bindings_autogen_%s.cc' % set_name), 'wb')
     GenerateSource(source_file, functions, set_name, used_extensions)
     source_file.close()
+    ClangFormat(source_file.name)
 
   if not options.verify_order:
     header_file = open(
         os.path.join(directory, 'gl_mock_autogen_gl.h'), 'wb')
     GenerateMockHeader(header_file, GL_FUNCTIONS, 'gl')
     header_file.close()
+    ClangFormat(header_file.name)
 
     header_file = open(os.path.join(directory, 'gl_bindings_autogen_mock.h'),
                        'wb')
     GenerateMockBindingsHeader(header_file, GL_FUNCTIONS)
     header_file.close()
+    ClangFormat(header_file.name)
 
     source_file = open(os.path.join(directory, 'gl_bindings_autogen_mock.cc'),
                        'wb')
     GenerateMockBindingsSource(source_file, GL_FUNCTIONS)
     source_file.close()
+    ClangFormat(source_file.name)
+
+    enum_header_filenames = [ResolveHeader(h, HEADER_PATHS)
+                             for h in GLES2_HEADERS_WITH_ENUMS]
+    header_file = open(os.path.join(directory,
+                                    '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:]))