Update from https://crrev.com/314320

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 921 matching lines @@
   'BufferParameter': {
     'type': 'GLenum',
     'valid': [
       'GL_BUFFER_SIZE',
       'GL_BUFFER_USAGE',
     ],
     'invalid': [
       'GL_PIXEL_PACK_BUFFER',
     ],
   },
+  'BufferMode': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_INTERLEAVED_ATTRIBS',
+      'GL_SEPARATE_ATTRIBS',
+    ],
+    'invalid': [
+      'GL_PIXEL_PACK_BUFFER',
+    ],
+  },
   'FrameBufferParameter': {
     'type': 'GLenum',
     'valid': [
       'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE',
       'GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME',
       'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL',
       'GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE',
     ],
   },
   'MatrixMode': {
@@ skipping 753 matching lines @@
   },
   'CopyTexImage2D': {
     'decoder_func': 'DoCopyTexImage2D',
     'unit_test': False,
     'defer_reads': True,
   },
   'CopyTexSubImage2D': {
     'decoder_func': 'DoCopyTexSubImage2D',
     'defer_reads': True,
   },
+  'CopyTexSubImage3D': {
+    'defer_reads': True,
+    'unsafe': True,
+  },
   'CreateImageCHROMIUM': {
     'type': 'Manual',
     'cmd_args':
         'ClientBuffer buffer, GLsizei width, GLsizei height, '
         'GLenum internalformat',
     'result': ['GLuint'],
     'client_test': False,
     'gen_cmd': False,
     'expectation': False,
     'extension': True,
@@ skipping 716 matching lines @@
     'first_element_only': True,
     'unsafe': True,
   },
   'ShaderBinary': {
     'type': 'Custom',
     'client_test': False,
   },
   'ShaderSource': {
     'type': 'PUTSTR',
     'decoder_func': 'DoShaderSource',
+    'expectation': False,
     'data_transfer_methods': ['bucket'],
     'cmd_args':
         'GLuint shader, const char** str',
     'pepper_args':
         'GLuint shader, GLsizei count, const char** str, const GLint* length',
   },
   'StencilMask': {
     'type': 'StateSetFrontBack',
     'state': 'StencilMask',
     'no_gl': True,
@@ skipping 77 matching lines @@
     'type': 'Manual',
     'data_transfer_methods': ['shm'],
     'client_test': False,
     'cmd_args': 'GLenumTextureTarget target, GLint level, '
                 'GLint xoffset, GLint yoffset, GLint zoffset, '
                 'GLsizei width, GLsizei height, GLsizei depth, '
                 'GLenumTextureFormat format, GLenumPixelType type, '
                 'const void* pixels, GLboolean internal',
     'unsafe': True,
   },
+  'TransformFeedbackVaryings': {
+    'type': 'PUTSTR',
+    'data_transfer_methods': ['bucket'],
+    'decoder_func': 'DoTransformFeedbackVaryings',
+    'cmd_args':
+        'GLuint program, const char** varyings, GLenum buffermode',
+    'unsafe': True,
+  },
   'Uniform1f': {'type': 'PUTXn', 'count': 1},
   'Uniform1fv': {
     'type': 'PUTn',
     'count': 1,
     'decoder_func': 'DoUniform1fv',
   },
   'Uniform1i': {'decoder_func': 'DoUniform1i', 'unit_test': False},
   'Uniform1iv': {
     'type': 'PUTn',
     'count': 1,
@@ skipping 3857 matching lines @@
           'data': data_arg.name,
           'length': length_arg.name if not length_arg == None else ''
       })
     for arg in func.GetOriginalArgs():
       arg.WriteClientSideValidationCode(file, func)
     size_code_block = """  // Compute the total size.
   base::CheckedNumeric<size_t> total_size = count;
   total_size += 1;
   total_size *= sizeof(GLint);
   if (!total_size.IsValid()) {
-    SetGLError(GL_INVALID_VALUE, "glShaderSource", "overflow");
+    SetGLError(GL_INVALID_VALUE, "gl%(func_name)s", "overflow");
     return;
   }
   size_t header_size = total_size.ValueOrDefault(0);
   std::vector<GLint> header(count + 1);
   header[0] = static_cast<GLint>(count);
   for (GLsizei ii = 0; ii < count; ++ii) {
     GLint len = 0;
     if (%(data)s[ii]) {"""
     if length_arg == None:
       size_code_block += """
-      len = base::static_cast<GLint>(strlen(%(data)s[ii]));"""
+      len = static_cast<GLint>(strlen(%(data)s[ii]));"""
     else:
       size_code_block += """
       len = (%(length)s && %(length)s[ii] >= 0) ?
           %(length)s[ii] : base::checked_cast<GLint>(strlen(%(data)s[ii]));"""
     size_code_block += """
     }
     total_size += len;
     total_size += 1;  // NULL at the end of each char array.
     if (!total_size.IsValid()) {
-      SetGLError(GL_INVALID_VALUE, "glShaderSource", "overflow");
+      SetGLError(GL_INVALID_VALUE, "gl%(func_name)s", "overflow");
       return;
     }
     header[ii + 1] = len;
 }
 """
     file.Write(size_code_block % {
-          'data': data_arg.name,
-          'length': length_arg.name if not length_arg == None else ''
+        'data': data_arg.name,
+        'length': length_arg.name if not length_arg == None else '',
+        'func_name': func.name,
       })
     data_code_block = """  // Pack data into a bucket on the service.
   helper_->SetBucketSize(kResultBucketId, total_size.ValueOrDefault(0));
   size_t offset = 0;
   for (GLsizei ii = 0; ii <= count; ++ii) {
     const char* src = (ii == 0) ? reinterpret_cast<const char*>(&header[0]) :
         %(data)s[ii - 1];
     base::CheckedNumeric<size_t> checked_size = (ii == 0) ? header_size :
         static_cast<size_t>(header[ii]);
     if (ii > 0) {
       checked_size += 1;  // NULL in the end.
     }
     if (!checked_size.IsValid()) {
-      SetGLError(GL_INVALID_VALUE, "glShaderSource", "overflow");
+      SetGLError(GL_INVALID_VALUE, "gl%(func_name)s", "overflow");
       return;
     }
     size_t size = checked_size.ValueOrDefault(0);
     while (size) {
       ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
       if (!buffer.valid() || buffer.size() == 0) {
-        SetGLError(GL_OUT_OF_MEMORY, "glShaderSource", "too large");
+        SetGLError(GL_OUT_OF_MEMORY, "gl%(func_name)s", "too large");
         return;
       }
       size_t copy_size = buffer.size();
       if (ii > 0 && buffer.size() == size)
         --copy_size;
       if (copy_size)
         memcpy(buffer.address(), src, copy_size);
       if (copy_size < buffer.size()) {
         // Append NULL in the end.
         DCHECK(copy_size + 1 == buffer.size());
         char* str = reinterpret_cast<char*>(buffer.address());
         str[copy_size] = 0;
       }
       helper_->SetBucketData(kResultBucketId, offset, buffer.size(),
                              buffer.shm_id(), buffer.offset());
       offset += buffer.size();
       src += buffer.size();
       size -= buffer.size();
     }
   }
   DCHECK_EQ(total_size.ValueOrDefault(0), offset);
 """
     file.Write(data_code_block % {
-          'data': data_arg.name,
-          'length': length_arg.name if not length_arg == None else ''
+        'data': data_arg.name,
+        'length': length_arg.name if not length_arg == None else '',
+        'func_name': func.name,
       })
-    bucket_cmd_arg_string = ""
-    for arg in func.GetCmdArgs()[0:-2]:
-      if bucket_cmd_arg_string:
-        bucket_cmd_arg_string += ", "
-      bucket_cmd_arg_string += arg.name
-    if bucket_cmd_arg_string:
-      bucket_cmd_arg_string += ", "
-    bucket_cmd_arg_string += 'kResultBucketId'
+    bucket_args = []
+    for arg in func.GetOriginalArgs():
+      if arg.name == 'count' or arg == self.__GetLengthArg(func):
+        continue
+      if arg == self.__GetDataArg(func):
+        bucket_args.append('kResultBucketId')
+      else:
+        bucket_args.append(arg.name)
     file.Write("  helper_->%sBucket(%s);\n" %
-               (func.name, bucket_cmd_arg_string))
+               (func.name, ", ".join(bucket_args)))
     file.Write("  helper_->SetBucketSize(kResultBucketId, 0);");
     file.Write("  CheckGLError();\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteGLES2ImplementationUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     code = """
 TEST_F(GLES2ImplementationTest, %(name)s) {
   const uint32 kBucketId = GLES2Implementation::kResultBucketId;
@@ skipping 10 matching lines @@
   const size_t kPaddedString2Size =
       transfer_buffer_->RoundToAlignment(kString2Size);
   struct Cmds {
     cmd::SetBucketSize set_bucket_size;
     cmd::SetBucketData set_bucket_header;
     cmd::SetToken set_token1;
     cmd::SetBucketData set_bucket_data1;
     cmd::SetToken set_token2;
     cmd::SetBucketData set_bucket_data2;
     cmd::SetToken set_token3;
-    cmds::ShaderSourceBucket shader_source_bucket;
+    cmds::%(name)sBucket cmd_bucket;
     cmd::SetBucketSize clear_bucket_size;
   };
 
   ExpectedMemoryInfo mem0 = GetExpectedMemory(kPaddedHeaderSize);
   ExpectedMemoryInfo mem1 = GetExpectedMemory(kPaddedString1Size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(kPaddedString2Size);
 
   Cmds expected;
   expected.set_bucket_size.Init(kBucketId, kSourceSize);
   expected.set_bucket_header.Init(
       kBucketId, 0, kHeaderSize, mem0.id, mem0.offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_data1.Init(
       kBucketId, kHeaderSize, kString1Size, mem1.id, mem1.offset);
   expected.set_token2.Init(GetNextToken());
   expected.set_bucket_data2.Init(
       kBucketId, kHeaderSize + kString1Size, kString2Size, mem2.id,
       mem2.offset);
   expected.set_token3.Init(GetNextToken());
-  expected.shader_source_bucket.Init(%(cmd_args)s, kBucketId);
+  expected.cmd_bucket.Init(%(bucket_args)s);
   expected.clear_bucket_size.Init(kBucketId, 0);
   const char* kStrings[] = { kString1, kString2 };
   gl_->%(name)s(%(gl_args)s);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
     gl_args = []
-    cmd_args = []
+    bucket_args = []
     for arg in func.GetOriginalArgs():
       if arg == self.__GetDataArg(func):
         gl_args.append('kStrings')
+        bucket_args.append('kBucketId')
       elif arg == self.__GetLengthArg(func):
         gl_args.append('NULL')
       elif arg.name == 'count':
         gl_args.append('2')
       else:
         gl_args.append(arg.GetValidClientSideArg(func))
-        cmd_args.append(arg.GetValidClientSideArg(func))
+        bucket_args.append(arg.GetValidClientSideArg(func))
     file.Write(code % {
         'name': func.name,
         'gl_args': ", ".join(gl_args),
-        'cmd_args': ", ".join(cmd_args),
+        'bucket_args': ", ".join(bucket_args),
       })
 
     if self.__GetLengthArg(func) == None:
       return
     code = """
 TEST_F(GLES2ImplementationTest, %(name)sWithLength) {
   const uint32 kBucketId = GLES2Implementation::kResultBucketId;
   const char* kString = "foobar******";
   const size_t kStringSize = 6;  // We only need "foobar".
   const size_t kHeaderSize = sizeof(GLint) * 2;
@@ skipping 16 matching lines @@
   ExpectedMemoryInfo mem1 = GetExpectedMemory(kPaddedStringSize);
 
   Cmds expected;
   expected.set_bucket_size.Init(kBucketId, kSourceSize);
   expected.set_bucket_header.Init(
       kBucketId, 0, kHeaderSize, mem0.id, mem0.offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_data.Init(
       kBucketId, kHeaderSize, kStringSize + 1, mem1.id, mem1.offset);
   expected.set_token2.Init(GetNextToken());
-  expected.shader_source_bucket.Init(%(cmd_args)s, kBucketId);
+  expected.shader_source_bucket.Init(%(bucket_args)s);
   expected.clear_bucket_size.Init(kBucketId, 0);
   const char* kStrings[] = { kString };
   const GLint kLength[] = { kStringSize };
   gl_->%(name)s(%(gl_args)s);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
     gl_args = []
     for arg in func.GetOriginalArgs():
       if arg == self.__GetDataArg(func):
         gl_args.append('kStrings')
       elif arg == self.__GetLengthArg(func):
         gl_args.append('kLength')
       elif arg.name == 'count':
         gl_args.append('1')
       else:
         gl_args.append(arg.GetValidClientSideArg(func))
     file.Write(code % {
         'name': func.name,
         'gl_args': ", ".join(gl_args),
-        'cmd_args': ", ".join(cmd_args),
+        'bucket_args': ", ".join(bucket_args),
       })
 
   def WriteBucketServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     cmd_args = []
     cmd_args_with_invalid_id = []
+    gl_args = []
     for index, arg in enumerate(func.GetOriginalArgs()):
-      if (arg == self.__GetLengthArg(func) or
-          arg == self.__GetDataArg(func) or arg.name == 'count'):
-        continue
-      if index == 0:  # Resource ID arg
+      if arg == self.__GetLengthArg(func):
+        gl_args.append('_')
+      elif arg.name == 'count':
+        gl_args.append('1')
+      elif arg == self.__GetDataArg(func):
+        cmd_args.append('kBucketId')
+        cmd_args_with_invalid_id.append('kBucketId')
+        gl_args.append('_')
+      elif index == 0:  # Resource ID arg
         cmd_args.append(arg.GetValidArg(func))
         cmd_args_with_invalid_id.append('kInvalidClientId')
+        gl_args.append(arg.GetValidGLArg(func))
       else:
         cmd_args.append(arg.GetValidArg(func))
         cmd_args_with_invalid_id.append(arg.GetValidArg(func))
+        gl_args.append(arg.GetValidGLArg(func))
 
     test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
+  EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   const uint32 kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
   SetBucketAsCStrings(kBucketId, 1, kSource, 1, kValidStrEnd);
   cmds::%(name)s cmd;
-  cmd.Init(%(cmd_args)s, kBucketId);
+  cmd.Init(%(cmd_args)s);
   decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));"""
     if func.IsUnsafe():
       test += """
   decoder_->set_unsafe_es3_apis_enabled(false);
   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 """
     test += """
 }
 """
     self.WriteValidUnitTest(func, file, test, {
         'cmd_args': ", ".join(cmd_args),
+        'gl_args': ", ".join(gl_args),
       }, *extras)
 
     test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   const uint32 kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
   decoder_->set_unsafe_es3_apis_enabled(true);
   cmds::%(name)s cmd;
   // Test no bucket.
-  cmd.Init(%(cmd_args)s, kBucketId);
+  cmd.Init(%(cmd_args)s);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   // Test invalid client.
   SetBucketAsCStrings(kBucketId, 1, kSource, 1, kValidStrEnd);
-  cmd.Init(%(cmd_args_with_invalid_id)s, kBucketId);
+  cmd.Init(%(cmd_args_with_invalid_id)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 """
     self.WriteValidUnitTest(func, file, test, {
         'cmd_args': ", ".join(cmd_args),
         'cmd_args_with_invalid_id': ", ".join(cmd_args_with_invalid_id),
       }, *extras)
 
     test = """
 TEST_P(%(test_name)s, %(name)sInvalidHeader) {
   const uint32 kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kValidStrEnd = 0;
   const GLsizei kCount = static_cast<GLsizei>(arraysize(kSource));
   const GLsizei kTests[] = {
-      kCount,
+      kCount + 1,
       0,
       std::numeric_limits<GLsizei>::max(),
       -1,
-      kCount,
   };
   decoder_->set_unsafe_es3_apis_enabled(true);
   for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
     SetBucketAsCStrings(kBucketId, 1, kSource, kTests[ii], kValidStrEnd);
     cmds::%(name)s cmd;
-    cmd.Init(%(cmd_args)s, kBucketId);
-    if (kTests[ii] == kCount) {
-      EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-    } else {
-      EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
-    }
+    cmd.Init(%(cmd_args)s);
+    EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
   }
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     self.WriteValidUnitTest(func, file, test, {
         'cmd_args': ", ".join(cmd_args),
       }, *extras)
 
     test = """
 TEST_P(%(test_name)s, %(name)sInvalidStringEnding) {
   const uint32 kBucketId = 123;
   const char kSource0[] = "hello";
   const char* kSource[] = { kSource0 };
   const char kInvalidStrEnd = '*';
   SetBucketAsCStrings(kBucketId, 1, kSource, 1, kInvalidStrEnd);
   cmds::%(name)s cmd;
-  cmd.Init(%(cmd_args)s, kBucketId);
+  cmd.Init(%(cmd_args)s);
   decoder_->set_unsafe_es3_apis_enabled(true);
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
-  EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     self.WriteValidUnitTest(func, file, test, {
         'cmd_args': ", ".join(cmd_args),
       }, *extras)
 
 
 class PUTXnHandler(ArrayArgTypeHandler):
   """Handler for glUniform?f functions."""
   def __init__(self):
@@ skipping 784 matching lines @@
     if func.IsImmediate():
       return 0
     return 1
 
   def GetInvalidArg(self, index):
     """overridden from Argument."""
     return ("-1", "kNoError", "GL_INVALID_VALUE")
 
   def WriteValidationCode(self, file, func):
     """overridden from Argument."""
-    file.Write("  if (%s < 0) {\n" % self.name)
-    file.Write(
-        "    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, \"gl%s\", \"%s < 0\");\n" %
-        (func.original_name, self.name))
-    file.Write("    return error::kNoError;\n")
-    file.Write("  }\n")
+    if func.IsUnsafe():
+      return
+    code = """  if (%(var_name)s < 0) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "gl%(func_name)s", "%(var_name)s < 0");
+    return error::kNoError;
+  }
+"""
+    file.Write(code % {
+        "var_name": self.name,
+        "func_name": func.original_name,
+      })
 
   def WriteClientSideValidationCode(self, file, func):
     """overridden from Argument."""
-    file.Write("  if (%s < 0) {\n" % self.name)
-    file.Write(
-        "    SetGLError(GL_INVALID_VALUE, \"gl%s\", \"%s < 0\");\n" %
-        (func.original_name, self.name))
-    file.Write("    return;\n")
-    file.Write("  }\n")
+    code = """  if (%(var_name)s < 0) {
+    SetGLError(GL_INVALID_VALUE, "gl%(func_name)s", "%(var_name)s < 0");
+    return;
+  }
+"""
+    file.Write(code % {
+        "var_name": self.name,
+        "func_name": func.original_name,
+      })
 
 
 class SizeNotNegativeArgument(SizeArgument):
   """class for GLsizeiNotNegative. It's NEVER allowed to be negative"""
 
   def __init__(self, name, type, gl_type):
     SizeArgument.__init__(self, name, gl_type)
 
   def GetInvalidArg(self, index):
     """overridden from SizeArgument."""
@@ skipping 2482 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:]))