Make command buffer generator infer GL array element type from the GL prototype

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 1220 matching lines @@
 # gen_cmd:      Whether or not this function geneates a command. Default = True.
 # immediate:    Whether or not to generate an immediate command for the GL
 #               function. The default is if there is exactly 1 pointer argument
 #               in the GL function an immediate command is generated.
 # bucket:       True to generate a bucket version of the command.
 # impl_func:    Whether or not to generate the GLES2Implementation part of this
 #               command.
 # impl_decl:    Whether or not to generate the GLES2Implementation declaration
 #               for this command.
 # needs_size:   If true a data_size field is added to the command.
-# data_type:    The type of data the command uses. For PUTn or PUT types.
 # count:        The number of units per element. For PUTn or PUT types.
 # unit_test:    If False no service side unit test will be generated.
 # client_test:  If False no client side unit test will be generated.
 # expectation:  If False the unit test will have no expected calls.
 # gen_func:     Name of function that generates GL resource for corresponding
 #               bind function.
 # states:       array of states that get set by this function corresponding to
 #               the given arguments
 # state_flag:   name of flag that is set to true when function is called.
 # no_gl:        no GL function is called.
@@ skipping 100 matching lines @@
   'ColorMask': {
     'type': 'StateSet',
     'state': 'ColorMask',
     'no_gl': True,
     'expectation': False,
   },
   'ConsumeTextureCHROMIUM': {
     'decoder_func': 'DoConsumeTextureCHROMIUM',
     'impl_func': False,
     'type': 'PUT',
-    'data_type': 'GLbyte',
     'count': 64,  # GL_MAILBOX_SIZE_CHROMIUM
     'unit_test': False,
     'client_test': False,
     'extension': True,
     'chromium': True,
     'trace_level': 1,
   },
   'ClearStencil': {
     'type': 'StateSet',
     'state': 'ClearStencil',
@@ skipping 573 matching lines @@
       'impl_func': False,
       'unit_test': False,
       'client_test': False,
       'extension': True,
       'chromium': True,
   },
   'ProduceTextureCHROMIUM': {
     'decoder_func': 'DoProduceTextureCHROMIUM',
     'impl_func': False,
     'type': 'PUT',
-    'data_type': 'GLbyte',
     'count': 64,  # GL_MAILBOX_SIZE_CHROMIUM
     'unit_test': False,
     'client_test': False,
     'extension': True,
     'chromium': True,
     'trace_level': 1,
   },
   'RenderbufferStorage': {
     'decoder_func': 'DoRenderbufferStorage',
     'gl_test_func': 'glRenderbufferStorageEXT',
@@ skipping 97 matching lines @@
     },
   },
   'TexParameteri': {
     'decoder_func': 'DoTexParameteri',
     'valid_args': {
       '2': 'GL_NEAREST'
     },
   },
   'TexParameterfv': {
     'type': 'PUT',
-    'data_type': 'GLfloat',
     'data_value': 'GL_NEAREST',
     'count': 1,
     'decoder_func': 'DoTexParameterfv',
     'gl_test_func': 'glTexParameterf',
     'first_element_only': True,
   },
   'TexParameteriv': {
     'type': 'PUT',
-    'data_type': 'GLint',
     'data_value': 'GL_NEAREST',
     'count': 1,
     'decoder_func': 'DoTexParameteriv',
     'gl_test_func': 'glTexParameteri',
     'first_element_only': True,
   },
   'TexSubImage2D': {
     'type': 'Manual',
     'immediate': False,
     'client_test': False,
     'cmd_args': 'GLenumTextureTarget target, GLint level, '
                 'GLint xoffset, GLint yoffset, '
                 'GLsizei width, GLsizei height, '
                 'GLenumTextureFormat format, GLenumPixelType type, '
                 'const void* pixels, GLboolean internal'
   },
-  'Uniform1f': {'type': 'PUTXn', 'data_type': 'GLfloat', 'count': 1},
+  'Uniform1f': {'type': 'PUTXn', 'count': 1},
   'Uniform1fv': {
     'type': 'PUTn',
-    'data_type': 'GLfloat',
     'count': 1,
     'decoder_func': 'DoUniform1fv',
   },
   'Uniform1i': {'decoder_func': 'DoUniform1i', 'unit_test': False},
   'Uniform1iv': {
     'type': 'PUTn',
-    'data_type': 'GLint',
     'count': 1,
     'decoder_func': 'DoUniform1iv',
     'unit_test': False,
   },
-  'Uniform2i': {'type': 'PUTXn', 'data_type': 'GLint', 'count': 2},
-  'Uniform2f': {'type': 'PUTXn', 'data_type': 'GLfloat', 'count': 2},
+  'Uniform2i': {'type': 'PUTXn', 'count': 2},
+  'Uniform2f': {'type': 'PUTXn', 'count': 2},
   'Uniform2fv': {
     'type': 'PUTn',
-    'data_type': 'GLfloat',
     'count': 2,
     'decoder_func': 'DoUniform2fv',
   },
   'Uniform2iv': {
     'type': 'PUTn',
-    'data_type': 'GLint',
     'count': 2,
     'decoder_func': 'DoUniform2iv',
   },
-  'Uniform3i': {'type': 'PUTXn', 'data_type': 'GLint', 'count': 3},
-  'Uniform3f': {'type': 'PUTXn', 'data_type': 'GLfloat', 'count': 3},
+  'Uniform3i': {'type': 'PUTXn', 'count': 3},
+  'Uniform3f': {'type': 'PUTXn', 'count': 3},
   'Uniform3fv': {
     'type': 'PUTn',
-    'data_type': 'GLfloat',
     'count': 3,
     'decoder_func': 'DoUniform3fv',
   },
   'Uniform3iv': {
     'type': 'PUTn',
-    'data_type': 'GLint',
     'count': 3,
     'decoder_func': 'DoUniform3iv',
   },
-  'Uniform4i': {'type': 'PUTXn', 'data_type': 'GLint', 'count': 4},
-  'Uniform4f': {'type': 'PUTXn', 'data_type': 'GLfloat', 'count': 4},
+  'Uniform4i': {'type': 'PUTXn', 'count': 4},
+  'Uniform4f': {'type': 'PUTXn', 'count': 4},
   'Uniform4fv': {
     'type': 'PUTn',
-    'data_type': 'GLfloat',
     'count': 4,
     'decoder_func': 'DoUniform4fv',
   },
   'Uniform4iv': {
     'type': 'PUTn',
-    'data_type': 'GLint',
     'count': 4,
     'decoder_func': 'DoUniform4iv',
   },
   'UniformMatrix2fv': {
     'type': 'PUTn',
-    'data_type': 'GLfloat',
     'count': 4,
     'decoder_func': 'DoUniformMatrix2fv',
   },
   'UniformMatrix3fv': {
     'type': 'PUTn',
-    'data_type': 'GLfloat',
     'count': 9,
     'decoder_func': 'DoUniformMatrix3fv',
   },
   'UniformMatrix4fv': {
     'type': 'PUTn',
-    'data_type': 'GLfloat',
     'count': 16,
     'decoder_func': 'DoUniformMatrix4fv',
   },
   'UnmapBufferCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
     'client_test': False,
   },
   'UnmapBufferSubDataCHROMIUM': {
@@ skipping 17 matching lines @@
     'pepper_interface': 'ChromiumMapSub',
   },
   'UseProgram': {
     'type': 'Bind',
     'decoder_func': 'DoUseProgram',
   },
   'ValidateProgram': {'decoder_func': 'DoValidateProgram'},
   'VertexAttrib1f': {'decoder_func': 'DoVertexAttrib1f'},
   'VertexAttrib1fv': {
     'type': 'PUT',
-    'data_type': 'GLfloat',
     'count': 1,
     'decoder_func': 'DoVertexAttrib1fv',
   },
   'VertexAttrib2f': {'decoder_func': 'DoVertexAttrib2f'},
   'VertexAttrib2fv': {
     'type': 'PUT',
-    'data_type': 'GLfloat',
     'count': 2,
     'decoder_func': 'DoVertexAttrib2fv',
   },
   'VertexAttrib3f': {'decoder_func': 'DoVertexAttrib3f'},
   'VertexAttrib3fv': {
     'type': 'PUT',
-    'data_type': 'GLfloat',
     'count': 3,
     'decoder_func': 'DoVertexAttrib3fv',
   },
   'VertexAttrib4f': {'decoder_func': 'DoVertexAttrib4f'},
   'VertexAttrib4fv': {
     'type': 'PUT',
-    'data_type': 'GLfloat',
     'count': 4,
     'decoder_func': 'DoVertexAttrib4fv',
   },
   'VertexAttribPointer': {
       'type': 'Manual',
       'cmd_args': 'GLuint indx, GLintVertexAttribSize size, '
                   'GLenumVertexAttribType type, GLboolean normalized, '
                   'GLsizei stride, GLuint offset',
       'client_test': False,
   },
@@ skipping 64 matching lines @@
     'cmd_args': 'GLenumDrawMode mode, GLint first, GLsizei count, '
                 'GLsizei primcount',
     'extension': True,
     'unit_test': False,
     'pepper_interface': 'InstancedArrays',
     'defer_draws': True,
   },
   'DrawBuffersEXT': {
     'type': 'PUTn',
     'decoder_func': 'DoDrawBuffersEXT',
-    'data_type': 'GLenum',
     'count': 1,
     'client_test': False,
     'unit_test': False,
     'extension': True,
     'pepper_interface': 'DrawBuffers',
   },
   'DrawElementsInstancedANGLE': {
     'type': 'Manual',
     'cmd_args': 'GLenumDrawMode mode, GLsizei count, '
                 'GLenumIndexType type, GLuint index_offset, GLsizei primcount',
@@ skipping 200 matching lines @@
   'WaitAllAsyncTexImage2DCHROMIUM': {
     'type': 'Manual',
     'immediate': False,
     'client_test': False,
     'extension': True,
     'chromium': True,
   },
   'DiscardFramebufferEXT': {
     'type': 'PUTn',
     'count': 1,
-    'data_type': 'GLenum',
     'cmd_args': 'GLenum target, GLsizei count, '
         'const GLenum* attachments',
     'decoder_func': 'DoDiscardFramebufferEXT',
     'unit_test': False,
     'client_test': False,
     'extension': True,
   },
   'LoseContextCHROMIUM': {
     'type': 'Manual',
     'impl_func': True,
@@ skipping 2176 matching lines @@
       static_cast<cmds::%(name)s::Result*>(shared_memory_address_);
   result->size = 0;
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));
   EXPECT_EQ(0u, result->size);%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test)
 
-
-class PUTHandler(TypeHandler):
-  """Handler for glTexParameter_v, glVertexAttrib_v functions."""
+class ArrayArgTypeHandler(TypeHandler):
+  """Base class for type handlers that handle args that are arrays"""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
+  def GetArrayType(self, func):
+    """Returns the type of the element in the element array being PUT to."""
+    for arg in func.GetOriginalArgs():
+      if arg.IsPointer():
+        element_type = arg.GetPointedType()
+        return element_type
+
+    # Special case: array type handler is used for a function that is forwarded
+    # to the actual array type implementation
+    element_type = func.GetOriginalArgs()[-1].type
+    assert all(arg.type == element_type \
+               for arg in func.GetOriginalArgs()[-self.GetArrayCount(func):])
+    return element_type
+
+  def GetArrayCount(self, func):
+    """Returns the count of the elements in the array being PUT to."""
+    return func.GetInfo('count')
+
+class PUTHandler(ArrayArgTypeHandler):
+  """Handler for glTexParameter_v, glVertexAttrib_v functions."""
+
+  def __init__(self):
+    ArrayArgTypeHandler.__init__(self)
+
   def WriteServiceUnitTest(self, func, file):
     """Writes the service unit test for a command."""
     expected_call = "EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));"
     if func.GetInfo("first_element_only"):
       gl_arg_strings = []
       for count, arg in enumerate(func.GetOriginalArgs()):
         gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
       gl_arg_strings[-1] = "*" + gl_arg_strings[-1]
       expected_call = ("EXPECT_CALL(*gl_, %%(gl_func_name)s(%s));" %
           ", ".join(gl_arg_strings))
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   GetSharedMemoryAs<%(data_type)s*>()[0] = %(data_value)s;
   %(expected_call)s
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     extra = {
-      'data_type': func.GetInfo('data_type'),
+      'data_type': self.GetArrayType(func),
       'data_value': func.GetInfo('data_value') or '0',
       'expected_call': expected_call,
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     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;
@@ skipping 21 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = []
     gl_any_strings = []
     for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
       gl_any_strings.append("_")
     extra = {
       'data_ref': ("*" if func.GetInfo('first_element_only') else ""),
-      'data_type': func.GetInfo('data_type'),
-      'data_count': func.GetInfo('count'),
+      'data_type': self.GetArrayType(func),
+      'data_count': self.GetArrayCount(func),
       'data_value': func.GetInfo('data_value') or '0',
       'gl_args': ", ".join(gl_arg_strings),
       'gl_any_args': ", ".join(gl_any_strings),
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s, _)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
   cmd.Init(%(all_but_last_args)s, &temp[0]);
   EXPECT_EQ(error::%(parse_result)s,
             ExecuteImmediateCmd(cmd, sizeof(temp)));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test, extra)
 
   def WriteGetDataSizeCode(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  uint32_t data_size;
   if (!ComputeDataSize(1, sizeof(%s), %d, &data_size)) {
     return error::kOutOfBounds;
   }
 """
-    file.Write(code % (func.info.data_type, func.info.count))
+    file.Write(code % (self.GetArrayType(func), self.GetArrayCount(func)))
     if func.is_immediate:
       file.Write("  if (data_size > immediate_data_size) {\n")
       file.Write("    return error::kOutOfBounds;\n")
       file.Write("  }\n")
 
   def WriteGLES2Implementation(self, func, file):
     """Overrriden from TypeHandler."""
     impl_func = func.GetInfo('impl_func')
     if (impl_func != None and impl_func != True):
       return;
     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)
     last_arg_name = func.GetLastOriginalArg().name
     values_str = ' << ", " << '.join(
-        ["%s[%d]" % (last_arg_name, ndx) for ndx in range(0, func.info.count)])
+        ["%s[%d]" % (last_arg_name, ndx) \
+         for ndx in range(0, self.GetArrayCount(func))])
     file.Write('  GPU_CLIENT_LOG("values: " << %s);\n' % values_str)
     for arg in func.GetOriginalArgs():
       arg.WriteClientSideValidationCode(file, func)
     file.Write("  helper_->%sImmediate(%s);\n" %
                (func.name, func.MakeOriginalArgString("")))
     file.Write("  CheckGLError();\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteGLES2ImplementationUnitTest(self, func, file):
@@ skipping 19 matching lines @@
 }
 """
     cmd_arg_strings = []
     for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
       cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
     gl_arg_strings = []
     for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
     file.Write(code % {
           'name': func.name,
-          'type': func.GetInfo('data_type'),
-          'count': func.GetInfo('count'),
+          'type': self.GetArrayType(func),
+          'count': self.GetArrayCount(func),
           'args': ", ".join(gl_arg_strings),
           'cmd_args': ", ".join(cmd_arg_strings),
         })
 
   def WriteImmediateCmdComputeSize(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  static uint32_t ComputeDataSize() {\n")
     file.Write("    return static_cast<uint32_t>(\n")
     file.Write("        sizeof(%s) * %d);  // NOLINT\n" %
-               (func.info.data_type, func.info.count))
+               (self.GetArrayType(func), self.GetArrayCount(func)))
     file.Write("  }\n")
     file.Write("\n")
     file.Write("  static uint32_t ComputeSize() {\n")
     file.Write("    return static_cast<uint32_t>(\n")
     file.Write(
         "        sizeof(ValueType) + ComputeDataSize());  // NOLINT\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdSetHeader(self, func, file):
@@ skipping 49 matching lines @@
     file.Write(code % {
           "name": func.name,
           "typed_args": func.MakeTypedOriginalArgString(""),
           "args": func.MakeOriginalArgString(""),
         })
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name)
     file.Write("  const int kSomeBaseValueToTestWith = 51;\n")
-    file.Write("  static %s data[] = {\n" % func.info.data_type)
-    for v in range(0, func.info.count):
+    file.Write("  static %s data[] = {\n" % self.GetArrayType(func))
+    for v in range(0, self.GetArrayCount(func)):
       file.Write("    static_cast<%s>(kSomeBaseValueToTestWith + %d),\n" %
-                 (func.info.data_type, v))
+                 (self.GetArrayType(func), v))
     file.Write("  };\n")
     file.Write("  cmds::%s& cmd = *GetBufferAs<cmds::%s>();\n" %
                (func.name, func.name))
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     args = func.GetCmdArgs()
     for value, arg in enumerate(args):
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value + 11))
     file.Write(",\n      data);\n")
     args = func.GetCmdArgs()
     file.Write("  EXPECT_EQ(static_cast<uint32_t>(cmds::%s::kCmdId),\n"
                % func.name)
     file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(sizeof(cmd) +\n")
     file.Write("            RoundSizeToMultipleOfEntries(sizeof(data)),\n")
     file.Write("            cmd.header.size * 4u);\n")
     for value, arg in enumerate(args):
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value + 11, arg.name))
     file.Write("  CheckBytesWrittenMatchesExpectedSize(\n")
     file.Write("      next_cmd, sizeof(cmd) +\n")
     file.Write("      RoundSizeToMultipleOfEntries(sizeof(data)));\n")
     file.Write("  // TODO(gman): Check that data was inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
-class PUTnHandler(TypeHandler):
+class PUTnHandler(ArrayArgTypeHandler):
   """Handler for PUTn 'glUniform__v' type functions."""
 
   def __init__(self):
-    TypeHandler.__init__(self)
+    ArrayArgTypeHandler.__init__(self)
 
   def WriteServiceUnitTest(self, func, file):
     """Overridden from TypeHandler."""
-    TypeHandler.WriteServiceUnitTest(self, func, file)
+    ArrayArgTypeHandler.WriteServiceUnitTest(self, func, file)
 
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgsCountTooLarge) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ skipping 39 matching lines @@
 }
 """
     gl_arg_strings = []
     gl_any_strings = []
     arg_strings = []
     for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
       gl_any_strings.append("_")
       arg_strings.append(arg.GetValidArg(func, count, 0))
     extra = {
-      'data_type': func.GetInfo('data_type'),
-      'data_count': func.GetInfo('count'),
+      'data_type': self.GetArrayType(func),
+      'data_count': self.GetArrayCount(func),
       'args': ", ".join(arg_strings),
       'gl_args': ", ".join(gl_arg_strings),
       'gl_any_args': ", ".join(gl_any_strings),
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_any_args)s, _)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   %(data_type)s temp[%(data_count)s * 2] = { 0, };
   cmd.Init(%(all_but_last_args)s, &temp[0]);
   EXPECT_EQ(error::%(parse_result)s,
             ExecuteImmediateCmd(cmd, sizeof(temp)));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test, extra)
 
   def WriteGetDataSizeCode(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  uint32_t data_size;
   if (!ComputeDataSize(count, sizeof(%s), %d, &data_size)) {
     return error::kOutOfBounds;
   }
 """
-    file.Write(code % (func.info.data_type, func.info.count))
+    file.Write(code % (self.GetArrayType(func), self.GetArrayCount(func)))
     if func.is_immediate:
       file.Write("  if (data_size > immediate_data_size) {\n")
       file.Write("    return error::kOutOfBounds;\n")
       file.Write("  }\n")
 
   def WriteGLES2Implementation(self, func, file):
     """Overrriden from TypeHandler."""
     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)
     last_arg_name = func.GetLastOriginalArg().name
     file.Write("""  GPU_CLIENT_LOG_CODE_BLOCK({
     for (GLsizei i = 0; i < count; ++i) {
 """)
     values_str = ' << ", " << '.join(
         ["%s[%d + i * %d]" % (
-            last_arg_name, ndx, func.info.count) for ndx in range(
-                0, func.info.count)])
+            last_arg_name, ndx, self.GetArrayCount(func)) for ndx in range(
+                0, self.GetArrayCount(func))])
     file.Write('       GPU_CLIENT_LOG("  " << i << ": " << %s);\n' % values_str)
     file.Write("    }\n  });\n")
     for arg in func.GetOriginalArgs():
       arg.WriteClientSideValidationCode(file, func)
     file.Write("  helper_->%sImmediate(%s);\n" %
                (func.name, func.MakeOriginalArgString("")))
     file.Write("  CheckGLError();\n")
     file.Write("}\n")
     file.Write("\n")
 
@@ skipping 22 matching lines @@
     for count, arg in enumerate(func.GetCmdArgs()[0:-2]):
       cmd_arg_strings.append(arg.GetValidClientSideCmdArg(func, count, 0))
     gl_arg_strings = []
     count_param = 0
     for count, arg in enumerate(func.GetOriginalArgs()[0:-1]):
       gl_arg_strings.append(arg.GetValidClientSideArg(func, count, 0))
       if arg.name == "count":
         count_param = int(arg.GetValidClientSideArg(func, count, 0))
     file.Write(code % {
           'name': func.name,
-          'type': func.GetInfo('data_type'),
-          'count': func.GetInfo('count'),
+          'type': self.GetArrayType(func),
+          'count': self.GetArrayCount(func),
           'args': ", ".join(gl_arg_strings),
           'cmd_args': ", ".join(cmd_arg_strings),
           'count_param': count_param,
         })
 
   def WriteImmediateCmdComputeSize(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  static uint32_t ComputeDataSize(GLsizei count) {\n")
     file.Write("    return static_cast<uint32_t>(\n")
     file.Write("        sizeof(%s) * %d * count);  // NOLINT\n" %
-               (func.info.data_type, func.info.count))
+               (self.GetArrayType(func), self.GetArrayCount(func)))
     file.Write("  }\n")
     file.Write("\n")
     file.Write("  static uint32_t ComputeSize(GLsizei count) {\n")
     file.Write("    return static_cast<uint32_t>(\n")
     file.Write(
         "        sizeof(ValueType) + ComputeDataSize(count));  // NOLINT\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdSetHeader(self, func, file):
@@ skipping 54 matching lines @@
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     args = func.GetCmdArgs()
     count_param = 0
     for value, arg in enumerate(args):
       if arg.name == "count":
         count_param = int(arg.GetValidClientSideArg(func, value, 0))
     file.Write("TEST_F(GLES2FormatTest, %s) {\n" % func.name)
     file.Write("  const int kSomeBaseValueToTestWith = 51;\n")
-    file.Write("  static %s data[] = {\n" % func.info.data_type)
-    for v in range(0, func.info.count * count_param):
+    file.Write("  static %s data[] = {\n" % self.GetArrayType(func))
+    for v in range(0, self.GetArrayCount(func) * count_param):
       file.Write("    static_cast<%s>(kSomeBaseValueToTestWith + %d),\n" %
-                 (func.info.data_type, v))
+                 (self.GetArrayType(func), v))
     file.Write("  };\n")
     file.Write("  cmds::%s& cmd = *GetBufferAs<cmds::%s>();\n" %
                (func.name, func.name))
     file.Write("  const GLsizei kNumElements = %d;\n" % count_param)
     file.Write("  const size_t kExpectedCmdSize =\n")
     file.Write("      sizeof(cmd) + kNumElements * sizeof(%s) * %d;\n" %
-               (func.info.data_type, func.info.count))
+               (self.GetArrayType(func), self.GetArrayCount(func)))
     file.Write("  void* next_cmd = cmd.Set(\n")
     file.Write("      &cmd")
     for value, arg in enumerate(args):
       file.Write(",\n      static_cast<%s>(%d)" % (arg.type, value + 1))
     file.Write(",\n      data);\n")
     file.Write("  EXPECT_EQ(static_cast<uint32_t>(cmds::%s::kCmdId),\n" %
                func.name)
     file.Write("            cmd.header.command);\n")
     file.Write("  EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);\n")
     for value, arg in enumerate(args):
       file.Write("  EXPECT_EQ(static_cast<%s>(%d), cmd.%s);\n" %
                  (arg.type, value + 1, arg.name))
     file.Write("  CheckBytesWrittenMatchesExpectedSize(\n")
     file.Write("      next_cmd, sizeof(cmd) +\n")
     file.Write("      RoundSizeToMultipleOfEntries(sizeof(data)));\n")
     file.Write("  // TODO(gman): Check that data was inserted;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
-class PUTXnHandler(TypeHandler):
+class PUTXnHandler(ArrayArgTypeHandler):
   """Handler for glUniform?f functions."""
   def __init__(self):
-    TypeHandler.__init__(self)
+    ArrayArgTypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  %(type)s temp[%(count)s] = { %(values)s};
   Do%(name)sv(%(location)s, 1, &temp[0]);
 """
     values = ""
     args = func.GetOriginalArgs()
-    count = int(func.GetInfo('count'))
+    count = int(self.GetArrayCount(func))
     num_args = len(args)
     for ii in range(count):
       values += "%s, " % args[len(args) - count + ii].name
 
     file.Write(code % {
         'name': func.name,
-        'count': func.GetInfo('count'),
-        'type': func.GetInfo('data_type'),
+        'count': self.GetArrayCount(func),
+        'type': self.GetArrayType(func),
         'location': args[0].name,
         'args': func.MakeOriginalArgString(""),
         'values': values,
       })
 
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(name)sv(%(local_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     args = func.GetOriginalArgs()
     local_args = "%s, 1, _" % args[0].GetValidGLArg(func, 0, 0)
     self.WriteValidUnitTest(func, file, valid_test, {
         'name': func.name,
-        'count': func.GetInfo('count'),
+        'count': self.GetArrayCount(func),
         'local_args': local_args,
       })
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
   EXPECT_CALL(*gl_, %(name)sv(_, _, _).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test, {
         'name': func.GetInfo('name'),
-        'count': func.GetInfo('count'),
+        'count': self.GetArrayCount(func),
       })
 
 
 class GLcharHandler(CustomHandler):
   """Handler for functions that pass a single string ."""
 
   def __init__(self):
     CustomHandler.__init__(self)
 
   def WriteImmediateCmdComputeSize(self, func, file):
@@ skipping 759 matching lines @@
 
 class ImmediatePointerArgument(Argument):
   """A class that represents an immediate argument to a function.
 
   An immediate argument is one where the data follows the command.
   """
 
   def __init__(self, name, type):
     Argument.__init__(self, name, type)
 
+  def IsPointer(self):
+    return True
+
+  def GetPointedType(self):
+    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, file):
     """Overridden from Argument."""
     file.Write(
       "  %s %s = GetImmediateDataAs<%s>(\n" %
       (self.type, self.name, self.type))
     file.Write("      c, data_size, immediate_data_size);\n")
@@ skipping 53 matching lines @@
 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."""
     return True
 
+  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, offset, index):
     """Overridden from Argument."""
     return "shared_memory_id_, shared_memory_offset_"
 
   def GetValidGLArg(self, func, offset, index):
     """Overridden from Argument."""
     return "reinterpret_cast<%s>(shared_memory_address_)" % self.type
 
   def GetNumInvalidValues(self, func):
     """Overridden from Argument."""
@@ skipping 1865 matching lines @@
       "ppapi/shared_impl/ppb_opengles2_shared.cc"])
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))