Command buffers: ensure we only read immediate data once

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 5964 matching lines @@
 """
     f.write(code)
 
   def WriteHandlerImplementation (self, func, f):
     """Overrriden from TypeHandler."""
     raise NotImplementedError("GENn functions are immediate")
 
   def WriteImmediateHandlerImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     param_name = func.GetLastOriginalArg().name
-    f.write("  if (!CheckUniqueAndNonNullIds(n, %s) || !%sHelper(n, %s)) {\n"
+    f.write("  auto %(name)s_copy = base::MakeUnique<GLuint[]>(n);\n"
+            "  GLuint* %(name)s_safe = %(name)s_copy.get();\n"
+            "  std::copy(%(name)s, %(name)s + n, %(name)s_safe);\n"
+            "  if (!CheckUniqueAndNonNullIds(n, %(name)s_safe) ||\n"
+            "      !%(func)sHelper(n, %(name)s_safe)) {\n"
             "    return error::kInvalidArguments;\n"
-            "  }\n" %
-            (param_name, func.original_name, param_name))
+            "  }\n" % {'name': param_name, 'func': func.original_name})
 
   def WriteGLES2Implementation(self, func, f):
     """Overrriden from TypeHandler."""
     log_code = ("""  GPU_CLIENT_LOG_CODE_BLOCK({
     for (GLsizei i = 0; i < n; ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << %s[i]);
     }
   });""" % func.GetOriginalArgs()[1].name)
     args = {
         'log_code': log_code,
@@ skipping 1023 matching lines @@
   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_client_args)s, &temp[0]);
   EXPECT_CALL(
       *gl_,
-      %(gl_func_name)s(%(gl_args)s, %(data_ref)sreinterpret_cast<
-          %(data_type)s*>(ImmediateDataAddress(&cmd))));"""
+      %(gl_func_name)s(%(gl_args)s, %(expectation)s));"""
     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)
+    data_count = self.GetArrayCount(func)
+    if func.GetInfo('first_element_only'):
+      expectation = "temp[0]"
+    else:
+      expectation = "PointsToArray(temp, %s)" % data_count
 
     extra = {
-      'data_ref': ("*" if func.GetInfo('first_element_only') else ""),
+      'expectation': expectation,
       'data_type': self.GetArrayType(func),
-      'data_count': self.GetArrayCount(func),
+      'data_count': data_count,
       '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>();"""
@@ skipping 274 matching lines @@
       'gl_args': ", ".join(gl_arg_strings),
       'args': ", ".join(arg_strings),
     }
     self.WriteValidUnitTest(func, f, valid_test, extra, *extras)
 
   def WriteImmediateServiceUnitTest(self, func, f, *extras):
     """Overridden from TypeHandler."""
     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 * 2] = { 0, };
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s,
-          reinterpret_cast<%(data_type)s*>(ImmediateDataAddress(&cmd))));
-  SpecializedSetup<cmds::%(name)s, 0>(true);
-  %(data_type)s temp[%(data_count)s * 2] = { 0, };
+          PointsToArray(temp, %(data_count)s)));
   cmd.Init(%(args)s, &temp[0]);"""
     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 += """
@@ skipping 1613 matching lines @@
     match = re.match('(const\s+)?(?P<element_type>[\w]+)\s*\*', self.type)
     assert match
     return match.groupdict()['element_type']
 
   def AddCmdArgs(self, args):
     """Overridden from Argument."""
     pass
 
   def WriteGetCode(self, f):
     """Overridden from Argument."""
-    f.write(
-      "  %s %s = GetImmediateDataAs<%s>(\n" %
-      (self.type, self.name, self.type))
+    f.write("  %s %s = GetImmediateDataAs<%s>(\n" %
+            (self.type, self.name, self.type))
     f.write("      c, data_size, immediate_data_size);\n")
 
   def WriteValidationCode(self, f, func):
     """Overridden from Argument."""
     if self.optional:
       return
     f.write("  if (%s == NULL) {\n" % self.name)
     f.write("    return error::kOutOfBounds;\n")
     f.write("  }\n")
 
@@ skipping 2296 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:]))