Make it possible to test command buffer decoder functions with extension flags

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 2620 matching lines @@
 def ToUnderscore(input_string):
   """converts CamelCase to camel_case."""
   words = SplitWords(input_string)
   return Lower(words)
 
 def CachedStateName(item):
   if item.get('cached', False):
     return 'cached_' + item['name']
   return item['name']
 
+def ToGLExtensionString(extension_flag):
+  """Returns GL-type extension string of a extension flag."""
+  if extension_flag == "oes_compressed_etc1_rgb8_texture":
+    return "OES_compressed_ETC1_RGB8_texture" # Fixup inconsitency with rgb8,
+                                              # unfortunate.

[piman, 2014/08/15 20:37:24]

Could we do the opposite, instead of trying to reverse-engineer the extension
name case from the flag name (which can be error prone), encode the extension
name in the call? some other things need it anyway (e.g. see
https://codereview.chromium.org/453163002 )

[Kimmo Kinnunen, 2014/08/20 05:59:05]

Ok, I'll see what I can do. (If I understand correctly, the suggestion was to
solve this in another patch.)

+  uppercase_words = [ 'img', 'ext', 'arb', 'chromium', 'oes', 'amd', 'bgra8888',
+                      'egl', 'atc', 'etc1', 'angle']
+  parts = extension_flag.split('_')
+  return "_".join(
+    [part.upper() if part in uppercase_words else part for part in parts])
+
+def ToCamelCase(input_string):
+  """converts ABC_underscore_case to ABCUnderscoreCase."""
+  return ''.join(w[0].upper() + w[1:] for w in input_string.split('_'))
 
 class CWriter(object):
   """Writes to a file formatting it for Google's style guidelines."""
 
   def __init__(self, filename):
     self.filename = filename
-    self.file_num = 0
     self.content = []
 
-  def SetFileNum(self, num):
-    """Used to help write number files and tests."""
-    self.file_num = num
-
   def Write(self, string):
     """Writes a string to a file spliting if it's > 80 characters."""
     lines = string.splitlines()
     num_lines = len(lines)
     for ii in range(0, num_lines):
       self.content.append(lines[ii])
       if ii < (num_lines - 1) or string[-1] == '\n':
         self.content.append('\n')
 
   def Close(self):
@@ skipping 264 matching lines @@
       file.Write("  error::Error error;\n")
     if defer_draws:
       file.Write("  error = WillAccessBoundFramebufferForDraw();\n")
       file.Write("  if (error != error::kNoError)\n")
       file.Write("    return error;\n")
     if defer_reads:
       file.Write("  error = WillAccessBoundFramebufferForRead();\n")
       file.Write("  if (error != error::kNoError)\n")
       file.Write("    return error;\n")
 
-  def WriteValidUnitTest(self, func, file, test, extra = {}):
+  def WriteValidUnitTest(self, func, file, test, *extras):
     """Writes a valid unit test for the service implementation."""
     if func.GetInfo('expectation') == False:
       test = self._remove_expected_call_re.sub('', test)
     name = func.name
     arg_strings = [
       arg.GetValidArg(func) \
       for arg in func.GetOriginalArgs() if not arg.IsConstant()
     ]
     gl_arg_strings = [
       arg.GetValidGLArg(func) \
       for arg in func.GetOriginalArgs()
     ]
     gl_func_name = func.GetGLTestFunctionName()
     vars = {
-      'test_name': 'GLES2DecoderTest%d' % file.file_num,
       'name':name,
       'gl_func_name': gl_func_name,
       'args': ", ".join(arg_strings),
       'gl_args': ", ".join(gl_arg_strings),
     }
-    vars.update(extra)
+    for extra in extras:
+      vars.update(extra)
     old_test = ""
     while (old_test != test):
       old_test = test
       test = test % vars
     file.Write(test % vars)
 
-  def WriteInvalidUnitTest(self, func, file, test, extra = {}):
+  def WriteInvalidUnitTest(self, func, file, test, *extras):
     """Writes an invalid unit test for the service implementation."""
     for invalid_arg_index, invalid_arg in enumerate(func.GetOriginalArgs()):
       # Service implementation does not test constants, as they are not part of
       # the call in the service side.
       if invalid_arg.IsConstant():
         continue
 
       num_invalid_values = invalid_arg.GetNumInvalidValues(func)
       for value_index in range(0, num_invalid_values):
         arg_strings = []
@@ skipping 10 matching lines @@
           arg_strings.append(arg_string)
         gl_arg_strings = []
         for arg in func.GetOriginalArgs():
           gl_arg_strings.append("_")
         gl_func_name = func.GetGLTestFunctionName()
         gl_error_test = ''
         if not gl_error == None:
           gl_error_test = '\n  EXPECT_EQ(%s, GetGLError());' % gl_error
 
         vars = {
-          'test_name': 'GLES2DecoderTest%d' % file.file_num ,
           'name': func.name,
           'arg_index': invalid_arg_index,
           'value_index': value_index,
           'gl_func_name': gl_func_name,
           'args': ", ".join(arg_strings),
           'all_but_last_args': ", ".join(arg_strings[:-1]),
           'gl_args': ", ".join(gl_arg_strings),
           'parse_result': parse_result,
             'gl_error_test': gl_error_test,
         }
-        vars.update(extra)
+        for extra in extras:
+          vars.update(extra)
         file.Write(test % vars)
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Writes the service unit test for a command."""
 
     if func.name == 'Enable':
       valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   SetupExpectationsForEnableDisable(%(gl_args)s, true);
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 15 matching lines @@
       valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   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());
 }
 """
-    self.WriteValidUnitTest(func, file, valid_test)
+    self.WriteValidUnitTest(func, file, valid_test, *extras)
 
     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;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
-    self.WriteInvalidUnitTest(func, file, invalid_test)
+    self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Writes the service unit test for an immediate command."""
     file.Write("// TODO(gman): %s\n" % func.name)
 
   def WriteImmediateValidationCode(self, func, file):
     """Writes the validation code for an immediate version of a command."""
     pass
 
-  def WriteBucketServiceUnitTest(self, func, file):
+  def WriteBucketServiceUnitTest(self, func, file, *extras):
     """Writes the service unit test for a bucket command."""
     file.Write("// TODO(gman): %s\n" % func.name)
 
   def WriteBucketValidationCode(self, func, file):
     """Writes the validation code for a bucket version of a command."""
     file.Write("// TODO(gman): %s\n" % func.name)
 
   def WriteGLES2ImplementationDeclaration(self, func, file):
     """Writes the GLES2 Implemention declaration."""
     impl_decl = func.GetInfo('impl_decl')
@@ skipping 277 matching lines @@
       file.Write("    %s = true;\n" % state['state_flag'])
     if not func.GetInfo("no_gl"):
       for ndx,item in enumerate(states):
         if item.get('cached', False):
           file.Write("    state_.%s = %s;\n" %
                      (CachedStateName(item), args[ndx].name))
       file.Write("    %s(%s);\n" %
                  (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
     file.Write("  }\n")
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
-    TypeHandler.WriteServiceUnitTest(self, func, file)
+    TypeHandler.WriteServiceUnitTest(self, func, file, *extras)
     state_name = func.GetInfo('state')
     state = _STATES[state_name]
     states = state['states']
     for ndx,item in enumerate(states):
       if 'range_checks' in item:
         for check_ndx, range_check in enumerate(item['range_checks']):
           valid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidValue%(ndx)d_%(check_ndx)d) {
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 """
           name = func.name
           arg_strings = [
             arg.GetValidArg(func) \
             for arg in func.GetOriginalArgs() if not arg.IsConstant()
           ]
 
           arg_strings[ndx] = range_check['test_value']
           vars = {
-            'test_name': 'GLES2DecoderTest%d' % file.file_num,
             'name': name,
             'ndx': ndx,
             'check_ndx': check_ndx,
             'args': ", ".join(arg_strings),
           }
+          for extra in extras:
+            vars.update(extra)
           file.Write(valid_test % vars)
       if 'nan_check' in item:
         valid_test = """
 TEST_P(%(test_name)s, %(name)sNaNValue%(ndx)d) {
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 """
         name = func.name
         arg_strings = [
           arg.GetValidArg(func) \
           for arg in func.GetOriginalArgs() if not arg.IsConstant()
         ]
 
         arg_strings[ndx] = 'nanf("")'
         vars = {
-          'test_name': 'GLES2DecoderTest%d' % file.file_num,
           'name': name,
           'ndx': ndx,
           'args': ", ".join(arg_strings),
         }
+        for extra in extras:
+          vars.update(extra)
         file.Write(valid_test % vars)
 
 
 class StateSetRGBAlphaHandler(TypeHandler):
   """Handler for commands that simply set state that have rgb/alpha."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteHandlerImplementation(self, func, file):
@@ skipping 127 matching lines @@
     pass
 
   def WriteImmediateServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteBucketServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
   def WriteImmediateCmdGetTotalSize(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "    uint32_t total_size = 0;  // TODO(gman): get correct size.\n")
 
   def WriteImmediateCmdInit(self, func, file):
     """Overrriden from TypeHandler."""
@@ skipping 82 matching lines @@
     return False
 
   def WriteStruct(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteDocs(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
-  def WriteBucketServiceUnitTest(self, func, file):
+  def WriteBucketServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteImmediateServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
@@ skipping 43 matching lines @@
       CustomHandler.InitFunction(self, func)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteBucketServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
   def WriteImmediateServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): Implement test for %s\n" % func.name)
@@ skipping 85 matching lines @@
                "cmd, total_size);\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     # TODO(gman): Remove this exception.
     file.Write("// TODO(gman): Implement test for %s\n" % func.name)
     return
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     file.Write("// TODO(gman): %s\n\n" % func.name)
 
   def WriteBucketServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     if not func.name == 'CompressedTexSubImage2DBucket':
       TypeHandler.WriteBucketServiceImplemenation(self, func, file)
 
 
 class BindHandler(TypeHandler):
   """Handler for glBind___ type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
 
     if len(func.GetOriginalArgs()) == 1:
       valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   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));
@@ skipping 10 matching lines @@
   cmds::%(name)s cmd;
   cmd.Init(kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(Get%(resource_type)s(kNewClientId) != NULL);
 }
 """
       self.WriteValidUnitTest(func, file, valid_test, {
           'resource_type': func.GetOriginalArgs()[0].resource_type,
           'gl_gen_func_name': func.GetInfo("gen_func"),
-      })
+      }, *extras)
     else:
       valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   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 10 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(Get%(resource_type)s(kNewClientId) != NULL);
 }
 """
       self.WriteValidUnitTest(func, file, valid_test, {
           'first_arg': func.GetOriginalArgs()[0].GetValidArg(func),
           'first_gl_arg': func.GetOriginalArgs()[0].GetValidGLArg(func),
           'resource_type': func.GetOriginalArgs()[1].resource_type,
           'gl_gen_func_name': func.GetInfo("gen_func"),
-      })
+      }, *extras)
 
     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;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
-    self.WriteInvalidUnitTest(func, file, invalid_test)
+    self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
 
   def WriteGLES2Implementation(self, func, file):
     """Writes the GLES2 Implemention."""
 
     impl_func = func.GetInfo('impl_func')
     impl_decl = func.GetInfo('impl_decl')
 
     if (func.can_auto_generate and
           (impl_func == None or impl_func == True) and
           (impl_decl == None or impl_decl == True)):
@@ skipping 166 matching lines @@
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(k%(types)sStartId, ids[0]);
   EXPECT_EQ(k%(types)sStartId + 1, ids[1]);
 }
 """
     file.Write(code % {
           'name': func.name,
           'types': func.GetInfo('resource_types'),
         })
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   GetSharedMemoryAs<GLuint*>()[0] = kNewClientId;
   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());
   EXPECT_TRUE(Get%(resource_name)s(kNewClientId) != NULL);
 }
 """
     self.WriteValidUnitTest(func, file, valid_test, {
         'resource_name': func.GetInfo('resource_type'),
-      })
+      }, *extras)
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
   GetSharedMemoryAs<GLuint*>()[0] = client_%(resource_name)s_id_;
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test, {
           'resource_name': func.GetInfo('resource_type').lower(),
-        })
+        }, *extras)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   cmds::%(name)s* cmd = GetImmediateAs<cmds::%(name)s>();
   GLuint temp = kNewClientId;
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmd->Init(1, &temp);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(Get%(resource_name)s(kNewClientId) != NULL);
 }
 """
     self.WriteValidUnitTest(func, file, valid_test, {
         'resource_name': func.GetInfo('resource_type'),
-      })
+      }, *extras)
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
   cmds::%(name)s* cmd = GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmd->Init(1, &client_%(resource_name)s_id_);
   EXPECT_EQ(error::kInvalidArguments,
             ExecuteImmediateCmd(*cmd, sizeof(&client_%(resource_name)s_id_)));
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test, {
           'resource_name': func.GetInfo('resource_type').lower(),
-        })
+        }, *extras)
 
   def WriteImmediateCmdComputeSize(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  static uint32_t ComputeDataSize(GLsizei n) {\n")
     file.Write(
         "    return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT\n")
     file.Write("  }\n")
     file.Write("\n")
     file.Write("  static uint32_t ComputeSize(GLsizei n) {\n")
     file.Write("    return static_cast<uint32_t>(\n")
@@ skipping 82 matching lines @@
 class CreateHandler(TypeHandler):
   """Handler for glCreate___ type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
     func.AddCmdArg(Argument("client_id", 'uint32_t'))
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
       .WillOnce(Return(kNewServiceId));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s%(comma)skNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(Get%(resource_type)s(kNewClientId) != NULL);
 }
 """
     comma = ""
     if len(func.GetOriginalArgs()):
       comma =", "
     self.WriteValidUnitTest(func, file, valid_test, {
           'comma': comma,
           'resource_type': func.name[6:],
-        })
+        }, *extras)
     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;
   cmd.Init(%(args)s%(comma)skNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test, {
           'comma': comma,
-        })
+        }, *extras)
 
   def WriteHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  uint32_t client_id = c.client_id;\n")
     file.Write("  if (!%sHelper(%s)) {\n" %
                (func.name, func.MakeCmdArgString("")))
     file.Write("    return error::kInvalidArguments;\n")
     file.Write("  }\n")
 
   def WriteGLES2Implementation(self, func, file):
@@ skipping 78 matching lines @@
   expected.data[1] = k%(types)sStartId + 1;
   gl_->%(name)s(arraysize(ids), &ids[0]);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 """
     file.Write(code % {
           'name': func.name,
           'types': func.GetInfo('resource_types'),
         })
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(1, Pointee(kService%(upper_resource_name)sId)))
       .Times(1);
   GetSharedMemoryAs<GLuint*>()[0] = client_%(resource_name)s_id_;
   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());
   EXPECT_TRUE(
       Get%(upper_resource_name)s(client_%(resource_name)s_id_) == NULL);
 }
 """
     self.WriteValidUnitTest(func, file, valid_test, {
           'resource_name': func.GetInfo('resource_type').lower(),
           'upper_resource_name': func.GetInfo('resource_type'),
-        })
+        }, *extras)
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   GetSharedMemoryAs<GLuint*>()[0] = kInvalidClientId;
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 """
-    self.WriteValidUnitTest(func, file, invalid_test)
+    self.WriteValidUnitTest(func, file, invalid_test, *extras)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(1, Pointee(kService%(upper_resource_name)sId)))
       .Times(1);
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmd.Init(1, &client_%(resource_name)s_id_);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(client_%(resource_name)s_id_)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(
       Get%(upper_resource_name)s(client_%(resource_name)s_id_) == NULL);
 }
 """
     self.WriteValidUnitTest(func, file, valid_test, {
           'resource_name': func.GetInfo('resource_type').lower(),
           'upper_resource_name': func.GetInfo('resource_type'),
-        })
+        }, *extras)
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   SpecializedSetup<cmds::%(name)s, 0>(false);
   GLuint temp = kInvalidClientId;
   cmd.Init(1, &temp);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
 }
 """
-    self.WriteValidUnitTest(func, file, invalid_test)
+    self.WriteValidUnitTest(func, file, invalid_test, *extras)
 
   def WriteHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  %sHelper(n, %s);\n" %
                (func.name, func.GetLastOriginalArg().name))
 
   def WriteImmediateHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  %sHelper(n, %s);\n" %
                (func.original_name, func.GetLastOriginalArg().name))
@@ skipping 269 matching lines @@
     gl_arg_strings = [first_gl_arg]
     for arg in func.GetOriginalArgs()[1:-1]:
       gl_arg_strings.append(arg.GetValidClientSideArg(func))
 
     file.Write(code % {
           'name': func.name,
           'args': ", ".join(gl_arg_strings),
           'cmd_args': ", ".join(cmd_arg_strings),
         })
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   SpecializedSetup<cmds::%(name)s, 0>(true);
   typedef cmds::%(name)s::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ skipping 16 matching lines @@
       if arg.name == 'pname':
         valid_pname = arg_value
     if func.GetInfo('gl_test_func') == 'glGetIntegerv':
       gl_arg_strings.append("_")
     else:
       gl_arg_strings.append("result->GetData()")
 
     self.WriteValidUnitTest(func, file, valid_test, {
         'local_gl_args': ", ".join(gl_arg_strings),
         'valid_pname': valid_pname,
-      })
+      }, *extras)
 
     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::Result* result =
       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)
+    self.WriteInvalidUnitTest(func, file, invalid_test, *extras)
 
 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():
@@ skipping 11 matching lines @@
   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):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """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 = [
         arg.GetValidGLArg(func) for arg in func.GetOriginalArgs()
       ]
       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': self.GetArrayType(func),
       'data_value': func.GetInfo('data_value') or '0',
       'expected_call': expected_call,
     }
-    self.WriteValidUnitTest(func, file, valid_test, extra)
+    self.WriteValidUnitTest(func, file, valid_test, extra, *extras)
 
     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;
   cmd.Init(%(args)s);
   GetSharedMemoryAs<%(data_type)s*>()[0] = %(data_value)s;
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
-    self.WriteInvalidUnitTest(func, file, invalid_test, extra)
+    self.WriteInvalidUnitTest(func, file, invalid_test, extra, *extras)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *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_args)s, &temp[0]);
   EXPECT_CALL(
       *gl_,
       %(gl_func_name)s(%(gl_args)s, %(data_ref)sreinterpret_cast<
           %(data_type)s*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     gl_arg_strings = [
       arg.GetValidGLArg(func) for arg in func.GetOriginalArgs()[0:-1]
     ]
     gl_any_strings = ["_"] * len(gl_arg_strings)
 
     extra = {
       'data_ref': ("*" if func.GetInfo('first_element_only') else ""),
       '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)
+    self.WriteValidUnitTest(func, file, 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>();
   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)
+    self.WriteInvalidUnitTest(func, file, invalid_test, extra, *extras)
 
   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 % (self.GetArrayType(func), self.GetArrayCount(func)))
     if func.IsImmediate():
@@ skipping 167 matching lines @@
     file.Write("}\n")
     file.Write("\n")
 
 
 class PUTnHandler(ArrayArgTypeHandler):
   """Handler for PUTn 'glUniform__v' type functions."""
 
   def __init__(self):
     ArrayArgTypeHandler.__init__(self)
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overridden from TypeHandler."""
-    ArrayArgTypeHandler.WriteServiceUnitTest(self, func, file)
+    ArrayArgTypeHandler.WriteServiceUnitTest(self, func, file, *extras)
 
     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 13 matching lines @@
         # the number of elements requested in the command.
         arg_strings.append("5")
       else:
         gl_arg_strings.append(arg.GetValidGLArg(func))
         if not arg.IsConstant():
           arg_strings.append(arg.GetValidArg(func))
     extra = {
       'gl_args': ", ".join(gl_arg_strings),
       'args': ", ".join(arg_strings),
     }
-    self.WriteValidUnitTest(func, file, valid_test, extra)
+    self.WriteValidUnitTest(func, file, valid_test, extra, *extras)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
+  def WriteImmediateServiceUnitTest(self, func, file, *extras):
     """Overridden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
   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, };
@@ skipping 11 matching lines @@
       gl_any_strings.append("_")
       if not arg.IsConstant():
         arg_strings.append(arg.GetValidArg(func))
     extra = {
       '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)
+    self.WriteValidUnitTest(func, file, 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>();
   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)
+    self.WriteInvalidUnitTest(func, file, invalid_test, extra, *extras)
 
   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 % (self.GetArrayType(func), self.GetArrayCount(func)))
     if func.IsImmediate():
@@ skipping 241 matching lines @@
 
     file.Write(code % {
         'name': func.name,
         'count': self.GetArrayCount(func),
         'type': self.GetArrayType(func),
         'location': args[0].name,
         'args': func.MakeOriginalArgString(""),
         'values': values,
       })
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """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)
     self.WriteValidUnitTest(func, file, valid_test, {
         'name': func.name,
         'count': self.GetArrayCount(func),
         'local_args': local_args,
-      })
+      }, *extras)
 
     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
 }
 """
@@ skipping 170 matching lines @@
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
     func.AddCmdArg(Argument("result_shm_id", 'uint32_t'))
     func.AddCmdArg(Argument("result_shm_offset", 'uint32_t'))
     if func.GetInfo('result') == None:
       func.AddInfo('result', ['uint32_t'])
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s%(comma)sshared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 """
     comma = ""
     if len(func.GetOriginalArgs()):
       comma =", "
     self.WriteValidUnitTest(func, file, valid_test, {
           'comma': comma,
-        })
+        }, *extras)
 
     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;
   cmd.Init(%(args)s%(comma)sshared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::%(parse_result)s, ExecuteCmd(cmd));%(gl_error_test)s
 }
 """
     self.WriteInvalidUnitTest(func, file, invalid_test, {
           'comma': comma,
-        })
+        }, *extras)
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgsBadSharedMemoryId) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s)).Times(0);
   SpecializedSetup<cmds::%(name)s, 0>(false);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s%(comma)skInvalidSharedMemoryId, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   cmd.Init(%(args)s%(comma)sshared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test, {
           'comma': comma,
-        })
+        }, *extras)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
         "    uint32_t immediate_data_size, const gles2::cmds::%s& c) {\n" %
         func.name)
     args = func.GetOriginalArgs()
     for arg in args:
@@ skipping 133 matching lines @@
       'dest_name': args[3].name,
       'arg0': args[0].name,
       'arg1': args[1].name,
       'arg2': args[2].name,
       'arg3': args[3].name,
     }
     file.Write(code_1 % str_args)
     func.WriteDestinationInitalizationValidation(file)
     file.Write(code_2 % str_args)
 
-  def WriteServiceUnitTest(self, func, file):
+  def WriteServiceUnitTest(self, func, file, *extras):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
   const char* kInfo = "hello";
   const uint32_t kBucketId = 123;
   SpecializedSetup<cmds::%(name)s, 0>(true);
 %(expect_len_code)s
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
       .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)),
                       SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1)));
@@ skipping 19 matching lines @@
         'gl_args': '%s, strlen(kInfo) + 1, _, _' %
              args[0].GetValidGLArg(func),
         'args': '%s, kBucketId' % args[0].GetValidArg(func),
         'expect_len_code': '',
     }
     if get_len_func and get_len_func[0:2] == 'gl':
       sub['expect_len_code'] = (
         "  EXPECT_CALL(*gl_, %s(%s, %s, _))\n"
         "      .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1));") % (
             get_len_func[2:], id_name, get_len_enum)
-    self.WriteValidUnitTest(func, file, valid_test, sub)
+    self.WriteValidUnitTest(func, file, valid_test, sub, *extras)
 
     invalid_test = """
 TEST_P(%(test_name)s, %(name)sInvalidArgs) {
   const uint32_t kBucketId = 123;
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _, _, _))
       .Times(0);
   cmds::%(name)s cmd;
   cmd.Init(kInvalidClientId, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 """
-    self.WriteValidUnitTest(func, file, invalid_test)
+    self.WriteValidUnitTest(func, file, invalid_test, *extras)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
 class NamedType(object):
   """A class that represents a type of an argument in a client function.
 
   A type of an argument that is to be passed through in the command buffer
   command. Currently used only for the arguments that are specificly named in
@@ skipping 1031 matching lines @@
     self.type_handler.WriteDocs(self, file)
 
   def WriteCmdHelper(self, file):
     """Writes the cmd's helper."""
     self.type_handler.WriteCmdHelper(self, file)
 
   def WriteServiceImplementation(self, file):
     """Writes the service implementation for a command."""
     self.type_handler.WriteServiceImplementation(self, file)
 
-  def WriteServiceUnitTest(self, file):
+  def WriteServiceUnitTest(self, file, *extras):
     """Writes the service implementation for a command."""
-    self.type_handler.WriteServiceUnitTest(self, file)
+    self.type_handler.WriteServiceUnitTest(self, file, *extras)
 
   def WriteGLES2CLibImplementation(self, file):
     """Writes the GLES2 C Lib Implemention."""
     self.type_handler.WriteGLES2CLibImplementation(self, file)
 
   def WriteGLES2InterfaceHeader(self, file):
     """Writes the GLES2 Interface declaration."""
     self.type_handler.WriteGLES2InterfaceHeader(self, file)
 
   def WriteGLES2InterfaceStub(self, file):
@@ skipping 108 matching lines @@
         self.original_name)
 
   def WriteServiceImplementation(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateServiceImplementation(self, file)
 
   def WriteHandlerImplementation(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateHandlerImplementation(self, file)
 
-  def WriteServiceUnitTest(self, file):
+  def WriteServiceUnitTest(self, file, *extras):
     """Writes the service implementation for a command."""
-    self.type_handler.WriteImmediateServiceUnitTest(self, file)
+    self.type_handler.WriteImmediateServiceUnitTest(self, file, *extras)
 
   def WriteValidationCode(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateValidationCode(self, file)
 
   def WriteCmdArgFlag(self, file):
     """Overridden from Function"""
     file.Write("  static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;\n")
 
   def WriteCmdComputeSize(self, file):
@@ skipping 57 matching lines @@
         self.original_name)
 
   def WriteServiceImplementation(self, file):
     """Overridden from Function"""
     self.type_handler.WriteBucketServiceImplementation(self, file)
 
   def WriteHandlerImplementation(self, file):
     """Overridden from Function"""
     self.type_handler.WriteBucketHandlerImplementation(self, file)
 
-  def WriteServiceUnitTest(self, file):
+  def WriteServiceUnitTest(self, file, *extras):
     """Writes the service implementation for a command."""
-    self.type_handler.WriteBucketServiceUnitTest(self, file)
+    self.type_handler.WriteBucketServiceUnitTest(self, file, *extras)
 
 
 def CreateArg(arg_string):
   """Creates an Argument."""
   arg_parts = arg_string.split()
   if len(arg_parts) == 1 and arg_parts[0] == 'void':
     return None
   # Is this a pointer argument?
   elif arg_string.find('*') >= 0:
     return PointerArgument(
@@ skipping 399 matching lines @@
 
             if 'extension_flag' in item:
               file.Write("  if (feature_info_->feature_flags().%s)\n  " %
                          item['extension_flag'])
             if test_prev:
               file.Write("  if (prev_state->%s != %s)\n" %
                          (item_name, item_name))
             file.Write("  gl%s(%s, %s);\n" %
                        (state['func'], item['enum'], item_name))
         else:
+          if 'extension_flag' in state:
+            file.Write("  if (feature_info_->feature_flags().%s)\n  " %
+                       state['extension_flag'])
           if test_prev:
             file.Write("  if (")
           args = []
           for place, item in enumerate(state['states']):
             item_name = CachedStateName(item)
             args.append('%s' % item_name)
             if test_prev:
               if place > 0:
                 file.Write(' ||\n')
               file.Write("(%s != prev_state->%s)" %
@@ skipping 125 matching lines @@
     """Writes the service decorder unit tests."""
     num_tests = len(self.functions)
     FUNCTIONS_PER_FILE = 98  # hard code this so it doesn't change.
     count = 0
     for test_num in range(0, num_tests, FUNCTIONS_PER_FILE):
       count += 1
       name = filename % count
       file = CHeaderWriter(
           name,
           "// It is included by gles2_cmd_decoder_unittest_%d.cc\n" % count)
-      file.SetFileNum(count)
+      test_name = 'GLES2DecoderTest%d' % count
       end = test_num + FUNCTIONS_PER_FILE
       if end > num_tests:
         end = num_tests
       for idx in range(test_num, end):
         func = self.functions[idx]
+
+        # Do any filtering of the functions here, so that the functions
+        # will not move between the numbered files if filtering properties
+        # are changed.
+        if func.GetInfo('extension_flag'):
+          continue
+
         if True:
         #gen_cmd = func.GetInfo('gen_cmd')
         #if gen_cmd == True or gen_cmd == None:
           if func.GetInfo('unit_test') == False:
             file.Write("// TODO(gman): %s\n" % func.name)
           else:
-            func.WriteServiceUnitTest(file)
+            func.WriteServiceUnitTest(file, {
+              'test_name': test_name
+            })
 
       file.Close()
     file = CHeaderWriter(
         filename % 0,
         "// It is included by gles2_cmd_decoder_unittest_base.cc\n")
     file.Write(
 """void GLES2DecoderTestBase::SetupInitCapabilitiesExpectations() {
 """)
     for capability in _CAPABILITY_FLAGS:
       file.Write("  ExpectEnableDisable(GL_%s, %s);\n" %
@@ skipping 17 matching lines @@
             else:
               args.append(item['default'])
           file.Write(
               "  EXPECT_CALL(*gl_, %s(%s, %s))\n" %
               (state['func'], ('GL_FRONT', 'GL_BACK')[ndx], ", ".join(args)))
           file.Write("      .Times(1)\n")
           file.Write("      .RetiresOnSaturation();\n")
       elif state['type'] == 'NamedParameter':
         for item in state['states']:
           if 'extension_flag' in item:
-            continue
+            file.Write("  if (group_->feature_info()->feature_flags().%s)\n" %
+                       item['extension_flag'])
+            file.Write("  ")
+
           file.Write(
               "  EXPECT_CALL(*gl_, %s(%s, %s))\n" %
               (state['func'], item['enum'], item['default']))
           file.Write("      .Times(1)\n")
           file.Write("      .RetiresOnSaturation();\n")
       else:
+        if 'extension_flag' in state:
+          file.Write("  if (group_->feature_info()->feature_flags().%s)\n" %
+                     state['extension_flag'])
+          file.Write("  ")
         args = []
         for item in state['states']:
           if 'expected' in item:
             args.append(item['expected'])
           else:
             args.append(item['default'])
         file.Write("  EXPECT_CALL(*gl_, %s(%s))\n" %
                    (state['func'], ", ".join(args)))
         file.Write("      .Times(1)\n")
         file.Write("      .RetiresOnSaturation();\n")
     file.Write("""}
 """)
     file.Close()
 
+  def WriteServiceUnitTestsForExtensions(self, filename):
+    """Writes the service decorder unit tests for functions with extension_flag.
+
+       The functions are special in that they need a specific unit test
+       baseclass to turn on the extension.
+    """
+    functions = [f for f in self.functions if f.GetInfo('extension_flag')]
+    file = CHeaderWriter(
+      filename,
+      "// It is included by gles2_cmd_decoder_unittest_extensions.cc\n")
+    for func in functions:
+      if True:
+        if func.GetInfo('unit_test') == False:
+          file.Write("// TODO(gman): %s\n" % func.name)
+        else:
+          extension = ToCamelCase(
+            ToGLExtensionString(func.GetInfo('extension_flag')))
+          func.WriteServiceUnitTest(file, {
+            'test_name': 'GLES2DecoderTestWith%s' % extension
+          })
+
+    file.Close()
+
   def WriteGLES2Header(self, filename):
     """Writes the GLES2 header."""
     file = CHeaderWriter(
         filename,
         "// This file contains Chromium-specific GLES2 declarations.\n\n")
 
     for func in self.original_functions:
       func.WriteGLES2Header(file)
 
     file.Write("\n")
@@ skipping 480 matching lines @@
       "client/gles2_trace_implementation_impl_autogen.h")
   gen.WriteGLES2CLibImplementation("client/gles2_c_lib_autogen.h")
   gen.WriteCmdHelperHeader("client/gles2_cmd_helper_autogen.h")
   gen.WriteServiceImplementation("service/gles2_cmd_decoder_autogen.h")
   gen.WriteServiceContextStateHeader("service/context_state_autogen.h")
   gen.WriteServiceContextStateImpl("service/context_state_impl_autogen.h")
   gen.WriteClientContextStateHeader("client/client_context_state_autogen.h")
   gen.WriteClientContextStateImpl(
       "client/client_context_state_impl_autogen.h")
   gen.WriteServiceUnitTests("service/gles2_cmd_decoder_unittest_%d_autogen.h")
+  gen.WriteServiceUnitTestsForExtensions(
+    "service/gles2_cmd_decoder_unittest_extensions_autogen.h")
   gen.WriteServiceUtilsHeader("service/gles2_cmd_validation_autogen.h")
   gen.WriteServiceUtilsImplementation(
       "service/gles2_cmd_validation_implementation_autogen.h")
   gen.WriteCommonUtilsHeader("common/gles2_cmd_utils_autogen.h")
   gen.WriteCommonUtilsImpl("common/gles2_cmd_utils_implementation_autogen.h")
   gen.WriteGLES2Header("../GLES2/gl2chromium_autogen.h")
   mojo_gles2_prefix = "../../mojo/public/c/gles2/gles2_call_visitor"
   gen.WriteMojoGLCallVisitor(mojo_gles2_prefix + "_autogen.h")
   gen.WriteMojoGLCallVisitorForExtension(
       mojo_gles2_prefix + "_chromium_texture_mailbox_autogen.h",
@@ skipping 42 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:]))