Implement GL_EXT_debug_marker

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 os
 import os.path
 import sys
@@ skipping 1696 matching lines @@
     'client_test': False,
     'gl_test_func': 'glGetQueryObjectuiv',
     'pepper_interface': 'Query',
   },
   'BindUniformLocationCHROMIUM': {
     'type': 'GLchar',
     'bucket': True,
     'needs_size': True,
     'gl_test_func': 'DoBindUniformLocationCHROMIUM',
   },
+  'InsertEventMarkerEXT': {
+    'type': 'GLcharN',
+    'decoder_func': 'DoInsertEventMarkerEXT',
+    'expectation': False,
+  },
+  'PushGroupMarkerEXT': {
+    'type': 'GLcharN',
+    'decoder_func': 'DoPushGroupMarkerEXT',
+    'expectation': False,
+  },
+  'PopGroupMarkerEXT': {
+    'decoder_func': 'DoPopGroupMarkerEXT',
+    'expectation': False,
+    'impl_func': False,
+  },
 }
 
 
 def SplitWords(input_string):
   """Transforms a input_string into a list of lower-case components.
 
   Args:
     input_string: the input string.
 
   Returns:
@@ skipping 493 matching lines @@
                (result_string, func.original_name,
                 func.MakeOriginalArgString("")))
     file.Write("}\n")
 
   def WriteClientGLCallLog(self, func, file):
     """Writes a logging macro for the client side code."""
     comma = ""
     if len(func.GetOriginalArgs()):
       comma = " << "
     file.Write(
-        '  GPU_CLIENT_LOG("[" << this << "] gl%s("%s%s << ")");\n' %
+        '  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] gl%s("%s%s << ")");\n' %
         (func.original_name, comma, func.MakeLogArgString()))
 
   def WriteClientGLReturnLog(self, func, file):
     """Writes the return value logging code."""
     if func.return_type != "void":
       file.Write('  GPU_CLIENT_LOG("return:" << result)\n')
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Writes the GLES2 Implemention."""
     impl_func = func.GetInfo('impl_func')
@@ skipping 2028 matching lines @@
 }
 
 """
     file.Write(code % {
           'func_name': func.name,
           'init_code': "\n".join(init_code),
           'check_code': "\n".join(check_code),
         })
 
 
+class GLcharNHandler(CustomHandler):
+  """Handler for functions that pass a single string with an optional len."""
+
+  def __init__(self):
+    CustomHandler.__init__(self)
+
+  def InitFunction(self, func):
+    """Overrriden from TypeHandler."""
+    func.cmd_args = []
+    func.AddCmdArg(Argument('bucket_id', 'GLuint'))
+
+  def AddImmediateFunction(self, generator, func):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def AddBucketFunction(self, generator, func):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteServiceImplementation(self, func, file):
+    """Overrriden from TypeHandler."""
+    file.Write("""error::Error GLES2DecoderImpl::Handle%(name)s(
+  uint32 immediate_data_size, const gles2::%(name)s& c) {
+  GLuint bucket_id = static_cast<GLuint>(c.%(bucket_id)s);
+  Bucket* bucket = GetBucket(bucket_id);
+  if (!bucket || bucket->size() == 0) {
+    return error::kInvalidArguments;
+  }
+  std::string str;
+  if (!bucket->GetAsString(&str)) {
+    return error::kInvalidArguments;
+  }
+  %(gl_func_name)s(0, str.c_str());
+  return error::kNoError;
+}
+
+""" % {
+    'name': func.name,
+    'gl_func_name': func.GetGLFunctionName(),
+    'bucket_id': func.cmd_args[0].name,
+  })
+
+
 class IsHandler(TypeHandler):
   """Handler for glIs____ type and glGetError functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
     func.AddCmdArg(Argument("result_shm_id", 'uint32'))
     func.AddCmdArg(Argument("result_shm_offset", 'uint32'))
@@ skipping 148 matching lines @@
     func.ClearCmdArgs()
     func.AddCmdArg(cmd_args[0])
     # add on a bucket id.
     func.AddCmdArg(Argument('bucket_id', 'uint32'))
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     code_1 = """%(return_type)s %(func_name)s(%(args)s) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
 """
-    code_2 = """  GPU_CLIENT_LOG("[" << this << "] gl%(func_name)s" << "("
+    code_2 = """  GPU_CLIENT_LOG("[" << GetLogPrefix()
+      << "] gl%(func_name)s" << "("
       << %(arg0)s << ", "
       << %(arg1)s << ", "
       << static_cast<void*>(%(arg2)s) << ", "
       << static_cast<void*>(%(arg3)s) << ")");
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->%(func_name)s(%(id_name)s, kResultBucketId);
   std::string str;
   GLsizei max_size = 0;
   if (GetBucketAsString(kResultBucketId, &str)) {
     if (bufsize > 0) {
@@ skipping 1157 matching lines @@
     self._type_handlers = {
       'Bind': BindHandler(),
       'Create': CreateHandler(),
       'Custom': CustomHandler(),
       'Data': DataHandler(),
       'Delete': DeleteHandler(),
       'DELn': DELnHandler(),
       'GENn': GENnHandler(),
       'GETn': GETnHandler(),
       'GLchar': GLcharHandler(),
+      'GLcharN': GLcharNHandler(),
       'HandWritten': HandWrittenHandler(),
       'Is': IsHandler(),
       'Manual': ManualHandler(),
       'PUT': PUTHandler(),
       'PUTn': PUTnHandler(),
       'PUTXn': PUTXnHandler(),
       'STRn': STRnHandler(),
       'Todo': TodoHandler(),
     }
 
@@ skipping 642 matching lines @@
     gen.WriteCommonUtilsImpl("common/gles2_cmd_utils_implementation_autogen.h")
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))