Improve BindBufferBase/BindBufferRange and a few other commands.

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 1413 matching lines @@
     'needs_size': True,
   },
   'BindBuffer': {
     'type': 'Bind',
     'decoder_func': 'DoBindBuffer',
     'gen_func': 'GenBuffersARB',
   },
   'BindBufferBase': {
     'type': 'Bind',
     'id_mapping': [ 'Buffer' ],
+    'gen_func': 'GenBuffersARB',
     'unsafe': True,
   },
   'BindFramebuffer': {
     'type': 'Bind',
     'decoder_func': 'DoBindFramebuffer',
     'gl_test_func': 'glBindFramebufferEXT',
     'gen_func': 'GenFramebuffersEXT',
     'trace_level': 1,
   },
   'BindRenderbuffer': {
@@ skipping 717 matching lines @@
     'expectation': False,
   },
   'IsShader': {
     'type': 'Is',
     'decoder_func': 'DoIsShader',
     'expectation': False,
   },
   'IsSampler': {
     'type': 'Is',
     'id_mapping': [ 'Sampler' ],
+    'expectation': False,
     'unsafe': True,
   },
   'IsTexture': {
     'type': 'Is',
     'decoder_func': 'DoIsTexture',
     'expectation': False,
   },
   'IsTransformFeedback': {
     'type': 'Is',
     'id_mapping': [ 'TransformFeedback' ],
+    'expectation': False,
     'unsafe': True,
   },
   'LinkProgram': {
     'decoder_func': 'DoLinkProgram',
     'impl_func':  False,
   },
   'MapBufferCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
@@ skipping 1042 matching lines @@
               'cmd_name': func.name,
               'field_name': name,
               'offset': offset,
             })
         offset += _SIZE_OF_UINT32
     file.Write("\n")
 
   def WriteHandlerImplementation(self, func, file):
     """Writes the handler implementation for this command."""
     if func.IsUnsafe() and func.GetInfo('id_mapping'):
+      code_no_gen = """  if (!group_->Get%(type)sServiceId(%(var)s, &%(var)s)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "%(func)s", "invalid %(var)s id");
+    return error::kNoError;
+  }
+"""
+      code_gen = """  if (!group_->Get%(type)sServiceId(%(var)s, &%(var)s)) {
+    if (!group_->bind_generates_resource()) {
+      LOCAL_SET_GL_ERROR(
+          GL_INVALID_OPERATION, "%(func)s", "invalid %(var)s id");
+      return error::kNoError;
+    }
+    GLuint client_id = %(var)s;
+    gl%(gen_func)s(1, &%(var)s);
+    Create%(type)s(client_id, %(var)s);
+  }
+"""
+      gen_func = func.GetInfo('gen_func')
       for id_type in func.GetInfo('id_mapping'):
-        file.Write("  group_->Get%sServiceId(%s, &%s);\n" %
-                   (id_type, id_type.lower(), id_type.lower()))
+        if gen_func and id_type in gen_func:
+          file.Write(code_gen % { 'type': id_type,
+                                  'var': id_type.lower(),
+                                  'func': func.GetGLFunctionName(),
+                                  'gen_func': gen_func })
+        else:
+          file.Write(code_no_gen % { 'type': id_type,
+                                     'var': id_type.lower(),
+                                     'func': func.GetGLFunctionName() })
     file.Write("  %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
   def WriteCmdSizeTest(self, func, file):
     """Writes the size test for a command."""
     file.Write("  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);\n")
 
   def WriteFormatTest(self, func, file):
     """Writes a format test for a command."""
     file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name)
@@ skipping 1136 matching lines @@
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 }
 """
       else:
         valid_test += """
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
       if func.GetInfo("gen_func"):
-          valid_test += """
+        valid_test += """
 TEST_P(%(test_name)s, %(name)sValidArgsNewId) {
-  EXPECT_CALL(*gl_, %(gl_func_name)s(%(first_gl_arg)s, kNewServiceId));
+  EXPECT_CALL(*gl_,
+              %(gl_func_name)s(%(all_except_last_gl_arg)s, kNewServiceId));
   EXPECT_CALL(*gl_, %(gl_gen_func_name)s(1, _))
      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
-  cmd.Init(%(first_arg)s, kNewClientId);
+  cmd.Init(%(all_except_last_arg)s, kNewClientId);"""
+        if func.IsUnsafe():
+          valid_test += """
+  decoder_->set_unsafe_es3_apis_enabled(true);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_NO_ERROR, GetGLError());
+  EXPECT_TRUE(Get%(resource_type)s(kNewClientId) != NULL);
+  decoder_->set_unsafe_es3_apis_enabled(false);
+  EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
+}
+"""
+        else:
+          valid_test += """
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(Get%(resource_type)s(kNewClientId) != NULL);
 }
 """
+
+      all_except_last_arg = [
+        arg.GetValidArg(func) for arg in func.GetOriginalArgs()[:-1]
+      ]
+      all_except_last_gl_arg = [
+        arg.GetValidGLArg(func) for arg in func.GetOriginalArgs()[:-1]
+      ]
       self.WriteValidUnitTest(func, file, valid_test, {
-          'first_arg': func.GetOriginalArgs()[0].GetValidArg(func),
-          'first_gl_arg': func.GetOriginalArgs()[0].GetValidGLArg(func),
+          'all_except_last_arg': ", ".join(all_except_last_arg),
+          'all_except_last_gl_arg': ", ".join(all_except_last_gl_arg),
           'resource_type': func.GetOriginalArgs()[-1].resource_type,
           'gl_gen_func_name': func.GetInfo("gen_func"),
       }, *extras)
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
@@ skipping 14 matching lines @@
 
       file.Write("%s GLES2Implementation::%s(%s) {\n" %
                  (func.return_type, func.original_name,
                   func.MakeTypedOriginalArgString("")))
       file.Write("  GPU_CLIENT_SINGLE_THREAD_CHECK();\n")
       func.WriteDestinationInitalizationValidation(file)
       self.WriteClientGLCallLog(func, file)
       for arg in func.GetOriginalArgs():
         arg.WriteClientSideValidationCode(file, func)
 
-      if func.IsUnsafe():
-        code = """  helper_->%(name)s(%(arg_string)s);
-  CheckGLError();
-}
-
-"""
-      else:
-        code = """  if (Is%(type)sReservedId(%(id)s)) {
+      code = """  if (Is%(type)sReservedId(%(id)s)) {
     SetGLError(GL_INVALID_OPERATION, "%(name)s\", \"%(id)s reserved id");
     return;
   }
   %(name)sHelper(%(arg_string)s);
   CheckGLError();
 }
 
 """
       name_arg = None
       if len(func.GetOriginalArgs()) == 1:
@@ skipping 1950 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;
   }
 """
     file.Write(code % {'func_name': func.name})
     func.WriteHandlerValidation(file)
-    if func.IsUnsafe() and func.GetInfo('id_mapping'):
-      for id_type in func.GetInfo('id_mapping'):
-        file.Write("  group_->Get%sServiceId(%s, &%s);\n" %
-                   (id_type, id_type.lower(), id_type.lower()))
-    file.Write("  *result_dst = %s(%s);\n" %
-               (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
+    if func.IsUnsafe():
+      assert func.GetInfo('id_mapping')
+      assert len(func.GetInfo('id_mapping')) == 1
+      id_type = func.GetInfo('id_mapping')[0]
+      file.Write("  *result_dst = group_->Get%sServiceId(%s, &%s);\n" %
+                 (id_type, id_type.lower(), id_type.lower()))
+    else:
+      file.Write("  *result_dst = %s(%s);\n" %
+                 (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
     file.Write("  return error::kNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteGLES2Implementation(self, func, file):
     """Overrriden from TypeHandler."""
     impl_func = func.GetInfo('impl_func')
     if impl_func == None or impl_func == True:
       error_value = func.GetInfo("error_value") or "GL_FALSE"
       file.Write("%s GLES2Implementation::%s(%s) {\n" %
@@ skipping 2822 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:]))