Add a mechanism for command buffer to conditionally allow ES3 enums.

gpu/command_buffer/build_gles2_cmd_buffer.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 GLES2 command buffers."""
 
 import itertools
 import os
 import os.path
@@ skipping 526 matching lines @@
       },
     ],
   },
 }
 
 # Named type info object represents a named type that is used in OpenGL call
 # arguments.  Each named type defines a set of valid OpenGL call arguments.  The
 # named types are used in 'cmd_buffer_functions.txt'.
 # type: The actual GL type of the named type.
 # valid: The list of values that are valid for both the client and the service.
+# valid_es3: The list of values that are valid in OpenGL ES 3, but not ES 2.
 # invalid: Examples of invalid values for the type. At least these values
 #          should be tested to be invalid.
 # is_complete: The list of valid values of type are final and will not be
 #              modified during runtime.
 _NAMED_TYPE_INFO = {
   'BlitFilter': {
     'type': 'GLenum',
     'valid': [
       'GL_NEAREST',
       'GL_LINEAR',
@@ skipping 20 matching lines @@
     'invalid': [
       'GL_FRAMEBUFFER',
     ],
   },
   'BufferTarget': {
     'type': 'GLenum',
     'valid': [
       'GL_ARRAY_BUFFER',
       'GL_ELEMENT_ARRAY_BUFFER',
     ],
+    'valid_es3': [
+      'GL_COPY_READ_BUFFER',
+      'GL_COPY_WRITE_BUFFER',
+      'GL_PIXEL_PACK_BUFFER',
+      'GL_PIXEL_UNPACK_BUFFER',
+      'GL_TRANSFORM_FEEDBACK_BUFFER',
+      'GL_UNIFORM_BUFFER',
+    ],
     'invalid': [
       'GL_RENDERBUFFER',
     ],
   },
   'IndexedBufferTarget': {
     'type': 'GLenum',
     'valid': [
       'GL_TRANSFORM_FEEDBACK_BUFFER',
       'GL_UNIFORM_BUFFER',
     ],
@@ skipping 6903 matching lines @@
   """
 
   def __init__(self, info):
     assert not 'is_complete' in info or info['is_complete'] == True
     self.info = info
     self.valid = info['valid']
     if 'invalid' in info:
       self.invalid = info['invalid']
     else:
       self.invalid = []
+    if 'valid_es3' in info:
+      self.valid_es3 = info['valid_es3']
+    else:
+      self.valid_es3 = []
 
   def GetType(self):
     return self.info['type']
 
   def GetInvalidValues(self):
     return self.invalid
 
   def GetValidValues(self):
     return self.valid
 
+  def GetValidValuesES3(self):
+    return self.valid_es3
+
   def IsConstant(self):
     if not 'is_complete' in self.info:
       return False
 
     return len(self.GetValidValues()) == 1
 
   def GetConstantValue(self):
     return self.GetValidValues()[0]
 
 class Argument(object):
@@ skipping 2279 matching lines @@
       named_type = NamedType(_NAMED_TYPE_INFO[name])
       if named_type.IsConstant():
         continue
       if named_type.GetValidValues():
         file.Write("static const %s valid_%s_table[] = {\n" %
                    (named_type.GetType(), ToUnderscore(name)))
         for value in named_type.GetValidValues():
           file.Write("  %s,\n" % value)
         file.Write("};\n")
         file.Write("\n")
+      if named_type.GetValidValuesES3():
+        file.Write("static const %s valid_%s_table_es3[] = {\n" %
+                   (named_type.GetType(), ToUnderscore(name)))
+        for value in named_type.GetValidValuesES3():
+          file.Write("  %s,\n" % value)
+        file.Write("};\n")
+        file.Write("\n")
     file.Write("Validators::Validators()")
     pre = '    : '
     for count, name in enumerate(names):
       named_type = NamedType(_NAMED_TYPE_INFO[name])
       if named_type.IsConstant():
         continue
       if named_type.GetValidValues():
         code = """%(pre)s%(name)s(
           valid_%(name)s_table, arraysize(valid_%(name)s_table))"""
       else:
         code = "%(pre)s%(name)s()"
       file.Write(code % {
         'name': ToUnderscore(name),
         'pre': pre,
       })
       pre = ',\n    '
     file.Write(" {\n");
     file.Write("}\n\n");
+
+    file.Write("void Validators::AddES3Values() {\n")
+    for name in names:
+      named_type = NamedType(_NAMED_TYPE_INFO[name])
+      if named_type.GetValidValuesES3():
+        code = """  %(name)s.AddValues(
+      valid_%(name)s_table_es3, arraysize(valid_%(name)s_table_es3));
+"""
+        file.Write(code % {
+          'name': ToUnderscore(name),
+        })
+    file.Write("}\n\n");
     file.Close()
     self.generated_cpp_filenames.append(file.filename)
 
   def WriteCommonUtilsHeader(self, filename):
     """Writes the gles2 common utility header."""
     file = CHeaderWriter(filename)
     type_infos = sorted(_NAMED_TYPE_INFO.keys())
     for type_info in type_infos:
       if _NAMED_TYPE_INFO[type_info]['type'] == 'GLenum':
         file.Write("static std::string GetString%s(uint32_t value);\n" %
@@ skipping 38 matching lines @@
 const size_t GLES2Util::enum_to_string_table_len_ =
     sizeof(enum_to_string_table) / sizeof(enum_to_string_table[0]);
 
 """)
 
     enums = sorted(_NAMED_TYPE_INFO.keys())
     for enum in enums:
       if _NAMED_TYPE_INFO[enum]['type'] == 'GLenum':
         file.Write("std::string GLES2Util::GetString%s(uint32_t value) {\n" %
                    enum)
-        if len(_NAMED_TYPE_INFO[enum]['valid']) > 0:
+        valid_list = _NAMED_TYPE_INFO[enum]['valid']
+        if 'valid_es3' in _NAMED_TYPE_INFO[enum]:
+          valid_list = valid_list + _NAMED_TYPE_INFO[enum]['valid_es3']
+        assert len(valid_list) == len(set(valid_list))
+        if len(valid_list) > 0:
           file.Write("  static const EnumToString string_table[] = {\n")
-          for value in _NAMED_TYPE_INFO[enum]['valid']:
+          for value in valid_list:
             file.Write('    { %s, "%s" },\n' % (value, value))
           file.Write("""  };
   return GLES2Util::GetQualifiedEnumString(
       string_table, arraysize(string_table), value);
 }
 
 """)
         else:
           file.Write("""  return GLES2Util::GetQualifiedEnumString(
       NULL, 0, value);
@@ skipping 344 matching lines @@
   Format(gen.generated_cpp_filenames)
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))