Implement SamplerManager in the command buffer

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 2240 matching lines @@
     'trace_level': 1,
   },
   'BindRenderbuffer': {
     'type': 'Bind',
     'decoder_func': 'DoBindRenderbuffer',
     'gl_test_func': 'glBindRenderbufferEXT',
     'gen_func': 'GenRenderbuffersEXT',
   },
   'BindSampler': {
     'type': 'Bind',
-    'id_mapping': [ 'Sampler' ],
+    'decoder_func': 'DoBindSampler',
+    'gen_func': 'GenSamplers',

[piman, 2015/12/05 02:45:19]

I don't think you need or want gen_func. glBindSampler doesn't implicitly
generate one if it's a new id.

     'unsafe': True,
   },
   'BindTexture': {
     'type': 'Bind',
     'decoder_func': 'DoBindTexture',
     'gen_func': 'GenTextures',
     # TODO: remove this once client side caching works.
     'client_test': False,
     'trace_level': 2,
   },
@@ skipping 364 matching lines @@
     'gl_test_func': 'glDeleteRenderbuffersEXT',
     'resource_type': 'Renderbuffer',
     'resource_types': 'Renderbuffers',
     'trace_level': 2,
   },
   'DeleteSamplers': {
     'type': 'DELn',
     'resource_type': 'Sampler',
     'resource_types': 'Samplers',
     'unsafe': True,
+    'useHelper': True

[piman, 2015/12/05 02:45:19]

nit: can you use a consistent style, 'use_helper'
Can you document what this means at the top of _FUNCTION_INFO ?

   },
   'DeleteShader': { 'type': 'Delete' },
   'DeleteSync': {
     'type': 'Delete',
     'cmd_args': 'GLuint sync',
     'resource_type': 'Sync',
     'unsafe': True,
   },
   'DeleteTextures': {
     'type': 'DELn',
@@ skipping 124 matching lines @@
     'type': 'GENn', 'gl_test_func': 'glGenRenderbuffersEXT',
     'resource_type': 'Renderbuffer',
     'resource_types': 'Renderbuffers',
   },
   'GenSamplers': {
     'type': 'GENn',
     'gl_test_func': 'glGenSamplers',
     'resource_type': 'Sampler',
     'resource_types': 'Samplers',
     'unsafe': True,
+    'useHelper': True,
   },
   'GenTextures': {
     'type': 'GENn',
     'gl_test_func': 'glGenTextures',
     'resource_type': 'Texture',
     'resource_types': 'Textures',
   },
   'GenTransformFeedbacks': {
     'type': 'GENn',
     'gl_test_func': 'glGenTransformFeedbacks',
@@ skipping 187 matching lines @@
     'expectation': False,
   },
   'GetRenderbufferParameteriv': {
     'type': 'GETn',
     'decoder_func': 'DoGetRenderbufferParameteriv',
     'gl_test_func': 'glGetRenderbufferParameterivEXT',
     'result': ['SizedResult<GLint>'],
   },
   'GetSamplerParameterfv': {
     'type': 'GETn',
+    'decoder_func': 'DoGetSamplerParameterfv',
     'result': ['SizedResult<GLfloat>'],
-    'id_mapping': [ 'Sampler' ],
     'unsafe': True,
   },
   'GetSamplerParameteriv': {
     'type': 'GETn',
+    'decoder_func': 'DoGetSamplerParameteriv',
     'result': ['SizedResult<GLint>'],
-    'id_mapping': [ 'Sampler' ],
     'unsafe': True,
   },
   'GetShaderiv': {
     'type': 'GETn',
     'decoder_func': 'DoGetShaderiv',
     'result': ['SizedResult<GLint>'],
   },
   'GetShaderInfoLog': {
     'type': 'STRn',
     'get_len_func': 'glGetShaderiv',
@@ skipping 217 matching lines @@
     'decoder_func': 'DoIsRenderbuffer',
     'expectation': False,
   },
   'IsShader': {
     'type': 'Is',
     'decoder_func': 'DoIsShader',
     'expectation': False,
   },
   'IsSampler': {
     'type': 'Is',
-    'id_mapping': [ 'Sampler' ],
+    'decoder_func': 'DoIsSampler',
     'expectation': False,
     'unsafe': True,
   },
   'IsSync': {
     'type': 'Is',
     'id_mapping': [ 'Sync' ],
     'cmd_args': 'GLuint sync',
     'expectation': False,
     'unsafe': True,
   },
@@ skipping 139 matching lines @@
     'decoder_func': 'DoReleaseShaderCompiler',
     'unit_test': False,
   },
   'ResumeTransformFeedback': {
     'unsafe': True,
   },
   'SamplerParameterf': {
     'valid_args': {
       '2': 'GL_NEAREST'
     },
-    'id_mapping': [ 'Sampler' ],
+    'decoder_func': 'DoSamplerParameterf',
     'unsafe': True,
   },
   'SamplerParameterfv': {
     'type': 'PUT',
     'data_value': 'GL_NEAREST',
     'count': 1,
     'gl_test_func': 'glSamplerParameterf',
     'decoder_func': 'DoSamplerParameterfv',
     'first_element_only': True,
-    'id_mapping': [ 'Sampler' ],
     'unsafe': True,
   },
   'SamplerParameteri': {
     'valid_args': {
       '2': 'GL_NEAREST'
     },
-    'id_mapping': [ 'Sampler' ],
+    'decoder_func': 'DoSamplerParameteri',
     'unsafe': True,
   },
   'SamplerParameteriv': {
     'type': 'PUT',
     'data_value': 'GL_NEAREST',
     'count': 1,
     'gl_test_func': 'glSamplerParameteri',
     'decoder_func': 'DoSamplerParameteriv',
     'first_element_only': True,
     'unsafe': True,
@@ skipping 2461 matching lines @@
 
   def WriteHandlerImplementation (self, func, f):
     """Overrriden from TypeHandler."""
     f.write("  if (!%sHelper(n, %s)) {\n"
                "    return error::kInvalidArguments;\n"
                "  }\n" %
                (func.name, func.GetLastOriginalArg().name))
 
   def WriteImmediateHandlerImplementation(self, func, f):
     """Overrriden from TypeHandler."""
-    if func.IsUnsafe():
+    if func.IsUnsafe() and not func.UseHelper():
       f.write("""  for (GLsizei ii = 0; ii < n; ++ii) {
     if (group_->Get%(resource_name)sServiceId(%(last_arg_name)s[ii], NULL)) {
       return error::kInvalidArguments;
     }
   }
   scoped_ptr<GLuint[]> service_ids(new GLuint[n]);
   gl%(func_name)s(n, service_ids.get());
   for (GLsizei ii = 0; ii < n; ++ii) {
     group_->Add%(resource_name)sId(%(last_arg_name)s[ii], service_ids[ii]);
   }
@@ skipping 84 matching lines @@
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
-    if func.IsUnsafe():
+    if func.IsUnsafe() and not func.UseHelper():
       valid_test += """
   GLuint service_id;
   EXPECT_TRUE(Get%(resource_name)sServiceId(kNewClientId, &service_id));
   EXPECT_EQ(kNewServiceId, service_id)
 }
 """
     else:
       valid_test += """
   EXPECT_TRUE(Get%(resource_name)s(kNewClientId, &service_id) != NULL);
 }
@@ skipping 25 matching lines @@
   GLuint temp = kNewClientId;
   SpecializedSetup<cmds::%(name)s, 0>(true);"""
     if func.IsUnsafe():
       valid_test += """
   decoder_->set_unsafe_es3_apis_enabled(true);"""
     valid_test += """
   cmd->Init(1, &temp);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
-    if func.IsUnsafe():
+    if func.IsUnsafe() and not func.UseHelper():
       valid_test += """
   GLuint service_id;
   EXPECT_TRUE(Get%(resource_name)sServiceId(kNewClientId, &service_id));
   EXPECT_EQ(kNewServiceId, service_id);
   decoder_->set_unsafe_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand,
             ExecuteImmediateCmd(*cmd, sizeof(temp)));
 }
 """
     else:
@@ skipping 281 matching lines @@
     f.write("  %sHelper(%s);\n" %
                (func.original_name, func.GetOriginalArgs()[-1].name))
     f.write("  CheckGLError();\n")
     f.write("}\n")
     f.write("\n")
 
   def WriteHandlerImplementation (self, func, f):
     """Overrriden from TypeHandler."""
     assert len(func.GetOriginalArgs()) == 1
     arg = func.GetOriginalArgs()[0]
-    if func.IsUnsafe():
+    if func.IsUnsafe() and not func.UseHelper():
       f.write("""  %(arg_type)s service_id = 0;
   if (group_->Get%(resource_type)sServiceId(%(arg_name)s, &service_id)) {
     glDelete%(resource_type)s(service_id);
     group_->Remove%(resource_type)sId(%(arg_name)s);
   } else {
      LOCAL_SET_GL_ERROR(
          GL_INVALID_VALUE, "gl%(func_name)s", "unknown %(arg_name)s");
   }
 """ % { 'resource_type': func.GetInfo('resource_type'),
         'arg_name': arg.name,
@@ skipping 80 matching lines @@
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmd.Init(1, &client_%(resource_name)s_id_);"""
     if func.IsUnsafe():
       valid_test += """
   decoder_->set_unsafe_es3_apis_enabled(true);"""
     valid_test += """
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(client_%(resource_name)s_id_)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
-    if func.IsUnsafe():
+    if func.IsUnsafe() and not func.UseHelper():
       valid_test += """
   EXPECT_FALSE(Get%(upper_resource_name)sServiceId(
       client_%(resource_name)s_id_, NULL));
   decoder_->set_unsafe_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand,
             ExecuteImmediateCmd(cmd, sizeof(client_%(resource_name)s_id_)));
 }
 """
     else:
       valid_test += """
@@ skipping 29 matching lines @@
 """
     self.WriteValidUnitTest(func, f, invalid_test, *extras)
 
   def WriteHandlerImplementation (self, func, f):
     """Overrriden from TypeHandler."""
     f.write("  %sHelper(n, %s);\n" %
                (func.name, func.GetLastOriginalArg().name))
 
   def WriteImmediateHandlerImplementation (self, func, f):
     """Overrriden from TypeHandler."""
-    if func.IsUnsafe():
+    if func.IsUnsafe() and not func.UseHelper():
       f.write("""  for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint service_id = 0;
     if (group_->Get%(resource_type)sServiceId(
             %(last_arg_name)s[ii], &service_id)) {
       glDelete%(resource_type)ss(1, &service_id);
       group_->Remove%(resource_type)sId(%(last_arg_name)s[ii]);
     }
   }
 """ % { 'resource_type': func.GetInfo('resource_type'),
         'last_arg_name': func.GetLastOriginalArg().name })
@@ skipping 439 matching lines @@
 """
     self.WriteInvalidUnitTest(func, f, invalid_test, extra, *extras)
 
   def WriteImmediateServiceUnitTest(self, func, f, *extras):
     """Writes the service unit test for a command."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
-  cmd.Init(%(gl_args)s, &temp[0]);
+  cmd.Init(%(gl_client_args)s, &temp[0]);
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s, %(data_ref)sreinterpret_cast<
           %(data_type)s*>(ImmediateDataAddress(&cmd))));"""
     if func.IsUnsafe():
       valid_test += """
   decoder_->set_unsafe_es3_apis_enabled(true);"""
     valid_test += """
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());"""
     if func.IsUnsafe():
       valid_test += """
   decoder_->set_unsafe_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand,
             ExecuteImmediateCmd(cmd, sizeof(temp)));"""
     valid_test += """
 }
 """
+    gl_client_arg_strings = [
+      arg.GetValidArg(func) for arg in func.GetOriginalArgs()[0:-1]
+    ]
     gl_arg_strings = [
       arg.GetValidGLArg(func) for arg in func.GetOriginalArgs()[0:-1]
     ]
     gl_any_strings = ["_"] * len(gl_arg_strings)
 
     extra = {
       'data_ref': ("*" if func.GetInfo('first_element_only') else ""),
       'data_type': self.GetArrayType(func),
       'data_count': self.GetArrayCount(func),
       'data_value': func.GetInfo('data_value') or '0',
+      'gl_client_args': ", ".join(gl_client_arg_strings),
       'gl_args': ", ".join(gl_arg_strings),
       'gl_any_args': ", ".join(gl_any_strings),
     }
     self.WriteValidUnitTest(func, f, valid_test, extra, *extras)
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();"""
     if func.IsUnsafe():
       invalid_test += """
@@ skipping 1204 matching lines @@
 
     code = """  typedef cmds::%(func_name)s::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
 """
     f.write(code % {'func_name': func.name})
     func.WriteHandlerValidation(f)
-    if func.IsUnsafe():
+    if func.IsUnsafe() and not func.HasDecoderFunc():

[piman, 2015/12/05 02:45:19]

Why does it matter whether here whether we renamed the decoder func to go
through the decoder or directly to GL?
Can we keep things orthogonal, and base it on UseHelper? What breaks?

       assert func.GetInfo('id_mapping')
       assert len(func.GetInfo('id_mapping')) == 1
       assert len(args) == 1
       id_type = func.GetInfo('id_mapping')[0]
       f.write("  %s service_%s = 0;\n" % (args[0].type, id_type.lower()))
       f.write("  *result_dst = group_->Get%sServiceId(%s, &service_%s);\n" %
                  (id_type, id_type.lower(), id_type.lower()))
     else:
       f.write("  *result_dst = %s(%s);\n" %
                  (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
@@ skipping 1043 matching lines @@
     self.type_handler.InitFunction(self)
 
   def IsImmediate(self):
     """Returns whether the function is immediate data function or not."""
     return False
 
   def IsUnsafe(self):
     """Returns whether the function has service side validation or not."""
     return self.GetInfo('unsafe', False)
 
+  def UseHelper(self):
+    """Returns whether the function has service side validation or not."""

[piman, 2015/12/05 02:45:19]

Can you fix the doc here? It's currently identical to IsUnsafe()

+    return self.GetInfo('useHelper', False)
+
   def GetInfo(self, name, default = None):
     """Returns a value from the function info for this function."""
     if name in self.info:
       return self.info[name]
     return default
 
   def GetValidArg(self, arg):
     """Gets a valid argument value for the parameter arg from the function info
     if one exists."""
     try:
@@ skipping 29 matching lines @@
 
   def GetErrorReturnString(self):
     if self.GetInfo("error_return"):
       return self.GetInfo("error_return")
     elif self.return_type == "GLboolean":
       return "GL_FALSE"
     elif "*" in self.return_type:
       return "NULL"
     return "0"
 
+  def HasDecoderFunc(self):
+    if self.GetInfo('decoder_func'):
+      return True
+    return False
+
   def GetGLFunctionName(self):
     """Gets the function to call to execute GL for this command."""
     if self.GetInfo('decoder_func'):
       return self.GetInfo('decoder_func')
     return "gl%s" % self.original_name
 
   def GetGLTestFunctionName(self):
     gl_func_name = self.GetInfo('gl_test_func')
     if gl_func_name == None:
       gl_func_name = self.GetGLFunctionName()
@@ skipping 1860 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:]))