texture mipmap level is not zero-only in ES 3

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 1990 matching lines @@
       '1',
       '2',
       '3',
       '4',
     ],
     'invalid': [
       '0',
       '5',
     ],
   },
-  'ZeroOnly': {
+  'ZeroOnlyForES2': {

[piman, 2015/11/17 23:40:06]

What is the point of GLintZeroOnlyForES2 (as opposed to GLint)?

This seems like a fair amount of complexity in this file, where in the end this
seems to have no actual effect on the generated code, since the ES2 check is in
non-generated code.
The only thing I see is 1 autogenerated test, but it's a lot fewer lines of code
to just move that one to non-autogenerated tests.

[yunchao, 2015/11/19 10:14:10]

Yeah. The code in build_gles2_cmd_buffer.py seems to be a little complex, but
the autogenerated code is not that much. However, it also makes the mipmap level
to be 0 for autogenerated test cases for framebufferTexture2D and
framebufferTexture2DMultisample in gles2_implementation_unittest_autogen.h and
gles2_cmd_decoder_unittest_1_autogen.h. Otherwise, the mipmap level would be
autogenerated to 5, then the test cases would fail. 

[zmo, 2015/11/19 19:15:00]

ZeroOnlyForES2 is misleading.  The code generator doesn't really generate codes
differently for ES2/ES3. The sole use of this is to generate 0 value for the ES2
tests.

Maybe it's better to remove this ZeroOnly thing as piman suggested, and move the
auto-generated tests to manual, so you can easily test the ES2 and ES3 cases
together (if not in one test, then a ES2 test followed by a ES3 test).

[yunchao, 2015/11/23 10:44:39]

Done.

     'type': 'GLint',
-    'is_complete': True,
+    'is_constant_for_es2': True,
     'valid': [
       '0',
     ],
     'invalid': [
       '1',
     ],
   },
   'FalseOnly': {
     'type': 'GLboolean',
     'is_complete': True,
@@ skipping 6382 matching lines @@
 
   def GetDeprecatedValuesES3(self):
     return self.deprecated_es3
 
   def IsConstant(self):
     if not 'is_complete' in self.info:
       return False
 
     return len(self.GetValidValues()) == 1
 
+  def IsConstantForES2(self):
+    if not 'is_constant_for_es2' in self.info:
+      return False
+
+    return len(self.GetValidValues()) == 1
+
   def GetConstantValue(self):
     return self.GetValidValues()[0]
 
 class Argument(object):
   """A class that represents a function argument."""
 
   cmd_type_map_ = {
     'GLenum': 'uint32_t',
     'GLint': 'int32_t',
     'GLintptr': 'int32_t',
@@ skipping 21 matching lines @@
     return False
 
   def IsPointer2D(self):
     """Returns true if argument is a 2D pointer."""
     return False
 
   def IsConstant(self):
     """Returns true if the argument has only one valid value."""
     return False
 
+  def IsConstantForES2(self):
+    """Returns true if the argument has only one valid value for ES2."""
+    return False
+
   def AddCmdArgs(self, args):
     """Adds command arguments for this argument to the given list."""
     if not self.IsConstant():
       return args.append(self)
 
   def AddInitArgs(self, args):
     """Adds init arguments for this argument to the given list."""
     if not self.IsConstant():
       return args.append(self)
 
@@ skipping 216 matching lines @@
     Argument.__init__(self, name, gl_type)
 
     self.gl_error = gl_error
     name = type[len(gl_type):]
     self.type_name = name
     self.named_type = NamedType(_NAMED_TYPE_INFO[name])
 
   def IsConstant(self):
     return self.named_type.IsConstant()
 
+  def IsConstantForES2(self):
+    return self.named_type.IsConstantForES2()
+
   def GetConstantValue(self):
     return self.named_type.GetConstantValue()
 
   def WriteValidationCode(self, f, func):
     if func.IsUnsafe():
       return
     if self.named_type.IsConstant():
       return
+    if self.named_type.IsConstantForES2():
+      return
     f.write("  if (!validators_->%s.IsValid(%s)) {\n" %
                (ToUnderscore(self.type_name), self.name))
     if self.gl_error == "GL_INVALID_ENUM":
       f.write(
           "    LOCAL_SET_GL_ERROR_INVALID_ENUM(\"gl%s\", %s, \"%s\");\n" %
           (func.original_name, self.name, self.name))
     else:
       f.write(
           "    LOCAL_SET_GL_ERROR(%s, \"gl%s\", \"%s %s\");\n" %
           (self.gl_error, func.original_name, self.name, self.gl_error))
@@ skipping 1930 matching lines @@
         func.WriteGLES2ImplementationUnitTest(f)
     self.generated_cpp_filenames.append(filename)
 
   def WriteServiceUtilsHeader(self, filename):
     """Writes the gles2 auto generated utility header."""
     with CHeaderWriter(filename) as f:
       for name in sorted(_NAMED_TYPE_INFO.keys()):
         named_type = NamedType(_NAMED_TYPE_INFO[name])
         if named_type.IsConstant():
           continue
+        if named_type.IsConstantForES2():
+          continue
         f.write("ValueValidator<%s> %s;\n" %
                    (named_type.GetType(), ToUnderscore(name)))
       f.write("\n")
     self.generated_cpp_filenames.append(filename)
 
   def WriteServiceUtilsImplementation(self, filename):
     """Writes the gles2 auto generated utility implementation."""
     with CHeaderWriter(filename) as f:
       names = sorted(_NAMED_TYPE_INFO.keys())
       for name in names:
         named_type = NamedType(_NAMED_TYPE_INFO[name])
         if named_type.IsConstant():
           continue
+        if named_type.IsConstantForES2():
+          continue
         if named_type.GetValidValues():
           f.write("static const %s valid_%s_table[] = {\n" %
                      (named_type.GetType(), ToUnderscore(name)))
           for value in named_type.GetValidValues():
             f.write("  %s,\n" % value)
           f.write("};\n")
           f.write("\n")
         if named_type.GetValidValuesES3():
           f.write("static const %s valid_%s_table_es3[] = {\n" %
                      (named_type.GetType(), ToUnderscore(name)))
           for value in named_type.GetValidValuesES3():
             f.write("  %s,\n" % value)
           f.write("};\n")
           f.write("\n")
         if named_type.GetDeprecatedValuesES3():
           f.write("static const %s deprecated_%s_table_es3[] = {\n" %
                      (named_type.GetType(), ToUnderscore(name)))
           for value in named_type.GetDeprecatedValuesES3():
             f.write("  %s,\n" % value)
           f.write("};\n")
           f.write("\n")
       f.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.IsConstantForES2():
+          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()"
         f.write(code % {
           'name': ToUnderscore(name),
           'pre': pre,
         })
         pre = ',\n    '
@@ skipping 413 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:]))