Fine tuning glGetInternalformativ.

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 2683 matching lines @@
   },
   'GetIntegeri_v': {
     'type': 'GETn',
     'result': ['SizedResult<GLint>'],
     'client_test': False,
     'unsafe': True
   },
   'GetInternalformativ': {
     'type': 'GETn',
     'result': ['SizedResult<GLint>'],
+    'unit_test': False,
     'unsafe': True,
   },
   'GetMaxValueInBufferCHROMIUM': {
     'type': 'Is',
     'decoder_func': 'DoGetMaxValueInBufferCHROMIUM',
     'result': ['GLuint'],
     'unit_test': False,
     'client_test': False,
     'extension': True,
     'chromium': True,
@@ skipping 3569 matching lines @@
 class GETnHandler(TypeHandler):
   """Handler for GETn for glGetBooleanv, glGetFloatv, ... type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def NeedsDataTransferFunction(self, func):
     """Overriden from TypeHandler."""
     return False
 
+  def __GetCountLimitValidation(self, func):
+    if func.name == 'GetInternalformativ':
+      return """
+  if (%(count_param)s > 0) {
+    // Sanity check for |bufSize| and set its upbound.
+    GLint value = 0;
+    LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("%(func_name)s");
+    glGetInternalformativ(
+        target, format, GL_NUM_SAMPLE_COUNTS, 1, &value);
+    GLenum error = LOCAL_PEEK_GL_ERROR("%(func_name)s");
+    if (error != GL_NO_ERROR) {
+      return error::kNoError;
+    }
+    if (value < %(count_param)s) {
+      %(count_param)s = value;
+    }
+  }
+"""

[piman, 2015/06/01 21:29:36]

I don't think this should belong to the generator. Can we make
GetInternalformativ a Custom or Manual type instead?

+    return None
+
+  def __GetCountParam(self, func):
+    for arg in func.GetCmdArgs():
+      if arg.name == 'bufSize':
+        return arg.name
+    return None
+
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     self.WriteServiceHandlerFunctionHeader(func, file)
     last_arg = func.GetLastOriginalArg()
     # All except shm_id and shm_offset.
     all_but_last_args = func.GetCmdArgs()[:-2]
     for arg in all_but_last_args:
       arg.WriteGetCode(file)
 
     code = """  typedef cmds::%(func_name)s::Result Result;
-  GLsizei num_values = 0;
-  GetNumValuesReturnedForGLGet(pname, &num_values);
+  GLsizei num_values = 0;"""
+    count_param = self.__GetCountParam(func)
+    if count_param:
+      count_param_validation = self.__GetCountLimitValidation(func)
+      if count_param_validation:
+        code += count_param_validation
+      code += """
+  if (%(count_param)s > 0) {
+    num_values = static_cast<GLsizei>(%(count_param)s);
+  }"""
+    else:
+      code += """
+  GetNumValuesReturnedForGLGet(pname, &num_values);"""
+    code += """
   Result* result = GetSharedMemoryAs<Result*>(
       c.%(last_arg_name)s_shm_id, c.%(last_arg_name)s_shm_offset,
       Result::ComputeSize(num_values));
   %(last_arg_type)s %(last_arg_name)s = result ? result->GetData() : NULL;
 """
     file.Write(code % {
         'last_arg_type': last_arg.type,
         'last_arg_name': last_arg.name,
         'func_name': func.name,
+        'count_param': count_param,
       })
     func.WriteHandlerValidation(file)
     code = """  // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
 """
     shadowed = func.GetInfo('shadowed')
     if not shadowed:
       file.Write('  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("%s");\n' % func.name)
     file.Write(code)
     func.WriteHandlerImplementation(file)
     if shadowed:
       code = """  result->SetNumResults(num_values);
   return error::kNoError;
 }
 """
     else:
-     code = """  GLenum error = glGetError();
+     code = """  GLenum error = LOCAL_PEEK_GL_ERROR("%(func_name)s");
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
-  } else {
-    LOCAL_SET_GL_ERROR(error, "%(func_name)s", "");
   }
   return error::kNoError;
 }
 
 """
     file.Write(code % {'func_name': func.name})
 
   def WriteGLES2Implementation(self, func, file):
     """Overrriden from TypeHandler."""
     impl_decl = func.GetInfo('impl_decl')
@@ skipping 4677 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:]))