Roll Chrome into Mojo.

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 1354 matching lines @@
     'valid': [
       'GL_GUILTY_CONTEXT_RESET_ARB',
       'GL_INNOCENT_CONTEXT_RESET_ARB',
       'GL_UNKNOWN_CONTEXT_RESET_ARB',
     ],
   },
   'SyncCondition': {
     'type': 'GLenum',
     'is_complete': True,
     'valid': [
-      #TODO(zmo): avoid using the direct number.
-      '0x9117',  # GL_SYNC_GPU_COMMANDS_COMPLETE
+      'GL_SYNC_GPU_COMMANDS_COMPLETE',
     ],
     'invalid': [
       '0',
     ],
   },
   'SyncFlags': {
     'type': 'GLbitfield',
     'is_complete': True,
     'valid': [
       '0',
@@ skipping 635 matching lines @@
     'data_transfer_methods': ['shm'],
     'cmd_args': 'GLidProgram program, void* result, uint32_t result_size',
     'result': ['SizedResult<GLuint>'],
   },
   'GetAttribLocation': {
     'type': 'Custom',
     'data_transfer_methods': ['shm'],
     'cmd_args':
         'GLidProgram program, uint32_t name_bucket_id, GLint* location',
     'result': ['GLint'],
-    'error_return': -1, # http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
+    'error_return': -1,
+  },
+  'GetFragDataLocation': {
+    'type': 'Custom',
+    'data_transfer_methods': ['shm'],
+    'cmd_args':
+        'GLidProgram program, uint32_t name_bucket_id, GLint* location',
+    'result': ['GLint'],
+    'error_return': -1,
+    'unsafe': True,
   },
   'GetBooleanv': {
     'type': 'GETn',
     'result': ['SizedResult<GLboolean>'],
     'decoder_func': 'DoGetBooleanv',
     'gl_test_func': 'glGetBooleanv',
   },
   'GetBufferParameteriv': {
     'type': 'GETn',
     'result': ['SizedResult<GLint>'],
@@ skipping 391 matching lines @@
     'unsafe': True,
   },
   'ShaderBinary': {
     'type': 'Custom',
     'client_test': False,
   },
   'ShaderSource': {
     'type': 'PUTSTR',
     'decoder_func': 'DoShaderSource',
     'data_transfer_methods': ['bucket'],
-    'client_test': False,
     '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,
     'expectation': False,
@@ skipping 1378 matching lines @@
               gl_arg_strings.append(arg.GetValidClientSideArg(func))
 
           file.Write(code % {
             'name': func.name,
             'invalid_index': func.GetOriginalArgs().index(invalid_arg),
             'args': ", ".join(gl_arg_strings),
             'gl_error': invalid[2],
           })
     else:
       if client_test != False:
-        file.Write("// TODO: Implement unit test for %s\n" % func.name)
+        file.Write("// TODO(zmo): Implement unit test for %s\n" % func.name)
 
   def WriteDestinationInitalizationValidation(self, func, file):
     """Writes the client side destintion initialization validation."""
     for arg in func.GetOriginalArgs():
       arg.WriteDestinationInitalizationValidation(file, func)
 
   def WriteTraceEvent(self, func, file):
     file.Write('  TRACE_EVENT0("gpu", "GLES2Implementation::%s");\n' %
                func.original_name)
 
@@ skipping 2646 matching lines @@
     if bucket_cmd_arg_string:
       bucket_cmd_arg_string += ", "
     bucket_cmd_arg_string += 'kResultBucketId'
     file.Write("  helper_->%sBucket(%s);\n" %
                (func.name, bucket_cmd_arg_string))
     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;
+  const char* kString1 = "happy";
+  const char* kString2 = "ending";
+  const size_t kString1Size = ::strlen(kString1) + 1;
+  const size_t kString2Size = ::strlen(kString2) + 1;
+  const size_t kHeaderSize = sizeof(GLint) * 3;
+  const size_t kSourceSize = kHeaderSize + kString1Size + kString2Size;
+  const size_t kPaddedHeaderSize =
+      transfer_buffer_->RoundToAlignment(kHeaderSize);
+  const size_t kPaddedString1Size =
+      transfer_buffer_->RoundToAlignment(kString1Size);
+  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;
+    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.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 = []
+    for arg in func.GetOriginalArgs():
+      if arg == self.__GetDataArg(func):
+        gl_args.append('kStrings')
+      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))
+    file.Write(code % {
+        'name': func.name,
+        'gl_args': ", ".join(gl_args),
+        'cmd_args': ", ".join(cmd_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;
+  const size_t kSourceSize = kHeaderSize + kStringSize + 1;
+  const size_t kPaddedHeaderSize =
+      transfer_buffer_->RoundToAlignment(kHeaderSize);
+  const size_t kPaddedStringSize =
+      transfer_buffer_->RoundToAlignment(kStringSize + 1);
+  struct Cmds {
+    cmd::SetBucketSize set_bucket_size;
+    cmd::SetBucketData set_bucket_header;
+    cmd::SetToken set_token1;
+    cmd::SetBucketData set_bucket_data;
+    cmd::SetToken set_token2;
+    cmds::ShaderSourceBucket shader_source_bucket;
+    cmd::SetBucketSize clear_bucket_size;
+  };
+
+  ExpectedMemoryInfo mem0 = GetExpectedMemory(kPaddedHeaderSize);
+  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.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),
+      })
+
+  def WriteBucketServiceUnitTest(self, func, file, *extras):
+    """Overrriden from TypeHandler."""
+    cmd_args = []
+    cmd_args_with_invalid_id = []
+    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
+        cmd_args.append(arg.GetValidArg(func))
+        cmd_args_with_invalid_id.append('kInvalidClientId')
+      else:
+        cmd_args.append(arg.GetValidArg(func))
+        cmd_args_with_invalid_id.append(arg.GetValidArg(func))
+
+    test = """
+TEST_P(%(test_name)s, %(name)sValidArgs) {
+  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);
+  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),
+      }, *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);
+  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
+  // Test invalid client.
+  SetBucketAsCStrings(kBucketId, 1, kSource, 1, kValidStrEnd);
+  cmd.Init(%(cmd_args_with_invalid_id)s, kBucketId);
+  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,
+      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));
+    }
+  }
+  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);
+  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):
     ArrayArgTypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  %(type)s temp[%(count)s] = { %(values)s};"""
     if func.IsUnsafe():
@@ skipping 1012 matching lines @@
 
   def WriteDestinationInitalizationValidation(self, file, func):
     """Overridden from Argument."""
     self.WriteDestinationInitalizationValidatationIfNeeded(file, func)
 
   def GetLogArg(self):
     """Overridden from Argument."""
     return "static_cast<const void*>(%s)" % self.name
 
 
-class BucketPointerArgument(Argument):
-  """A class that represents an bucket argument to a function."""
-
-  def __init__(self, name, type):
-    Argument.__init__(self, name, type)
-
-  def AddCmdArgs(self, args):
-    """Overridden from Argument."""
-    pass
-
-  def WriteGetCode(self, file):
-    """Overridden from Argument."""
-    file.Write(
-      "  %s %s = bucket->GetData(0, data_size);\n" %
-      (self.type, self.name))
-
-  def WriteValidationCode(self, file, func):
-    """Overridden from Argument."""
-    pass
-
-  def GetImmediateVersion(self):
-    """Overridden from Argument."""
-    return None
-
-  def WriteDestinationInitalizationValidation(self, file, func):
-    """Overridden from Argument."""
-    self.WriteDestinationInitalizationValidatationIfNeeded(file, func)
-
-  def GetLogArg(self):
-    """Overridden from Argument."""
-    return "static_cast<const void*>(%s)" % self.name
-
-
 class PointerArgument(Argument):
   """A class that represents a pointer argument to a function."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name, type)
 
   def IsPointer(self):
-    """Returns true if argument is a pointer."""
+    """Overridden from Argument."""
     return True
 
   def IsPointer2D(self):
-    """Returns true if argument is a 2D pointer."""
+    """Overridden from Argument."""
     return self.type.count('*') == 2
 
   def GetPointedType(self):
     match = re.match('(const\s+)?(?P<element_type>[\w]+)\s*\*', self.type)
     assert match
     return match.groupdict()['element_type']
 
   def GetValidArg(self, func):
     """Overridden from Argument."""
     return "shared_memory_id_, shared_memory_offset_"
@@ skipping 57 matching lines @@
       if self.IsPointer2D():
         return InputStringArrayBucketArgument(self.name, self.type)
       return InputStringBucketArgument(self.name, self.type)
     return BucketPointerArgument(self.name, self.type)
 
   def WriteDestinationInitalizationValidation(self, file, func):
     """Overridden from Argument."""
     self.WriteDestinationInitalizationValidatationIfNeeded(file, func)
 
 
+class BucketPointerArgument(PointerArgument):
+  """A class that represents an bucket argument to a function."""
+
+  def __init__(self, name, type):
+    Argument.__init__(self, name, type)
+
+  def AddCmdArgs(self, args):
+    """Overridden from Argument."""
+    pass
+
+  def WriteGetCode(self, file):
+    """Overridden from Argument."""
+    file.Write(
+      "  %s %s = bucket->GetData(0, data_size);\n" %
+      (self.type, self.name))
+
+  def WriteValidationCode(self, file, func):
+    """Overridden from Argument."""
+    pass
+
+  def GetImmediateVersion(self):
+    """Overridden from Argument."""
+    return None
+
+  def WriteDestinationInitalizationValidation(self, file, func):
+    """Overridden from Argument."""
+    self.WriteDestinationInitalizationValidatationIfNeeded(file, func)
+
+  def GetLogArg(self):
+    """Overridden from Argument."""
+    return "static_cast<const void*>(%s)" % self.name
+
+
 class InputStringBucketArgument(Argument):
   """A string input argument where the string is passed in a bucket."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name + "_bucket_id", "uint32_t")
 
+  def IsPointer(self):
+    """Overridden from Argument."""
+    return True
+
+  def IsPointer2D(self):
+    """Overridden from Argument."""
+    return False
+
 
 class InputStringArrayBucketArgument(Argument):
   """A string array input argument where the strings are passed in a bucket."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name + "_bucket_id", "uint32_t")
     self._original_name = name
 
   def WriteGetCode(self, file):
     """Overridden from Argument."""
@@ skipping 45 matching lines @@
         'name': self.name,
         'original_name': self._original_name,
       })
 
   def GetValidArg(self, func):
     return "kNameBucketId"
 
   def GetValidGLArg(self, func):
     return "_"
 
+  def IsPointer(self):
+    """Overridden from Argument."""
+    return True
+
+  def IsPointer2D(self):
+    """Overridden from Argument."""
+    return True
+
 
 class ResourceIdArgument(Argument):
   """A class that represents a resource id argument to a function."""
 
   def __init__(self, name, type):
     match = re.match("(GLid\w+)", type)
     self.resource_type = match.group(1)[4:]
     if self.resource_type == "Sync":
       type = type.replace(match.group(1), "GLsync")
     else:
@@ skipping 883 matching lines @@
     file.Write("#undef GLES2_CMD_OP\n")
     file.Write("  kNumCommands\n")
     file.Write("};\n")
     file.Write("\n")
     file.Close()
     self.generated_cpp_filenames.append(file.filename)
 
   def WriteFormat(self, filename):
     """Writes the command buffer format"""
     file = CHeaderWriter(filename)
+    # Forward declaration of a few enums used in constant argument
+    # to avoid including GL header files.
+    enum_defines = {
+        'GL_SYNC_GPU_COMMANDS_COMPLETE': 0x9117,
+      }
+    file.Write('\n')
+    for enum in enum_defines:
+      file.Write("#define %s 0x%x\n" % (enum, enum_defines[enum]))
+    file.Write('\n')
     for func in self.functions:
       if True:
       #gen_cmd = func.GetInfo('gen_cmd')
       #if gen_cmd == True or gen_cmd == None:
         func.WriteStruct(file)
     file.Write("\n")
     file.Close()
     self.generated_cpp_filenames.append(file.filename)
 
   def WriteDocs(self, filename):
@@ skipping 1142 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:]))