Add generated and hand-written passthrough command handlers with stub Doers.

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 4908 matching lines @@
       """ % {'name': func.name})
     if func.IsUnsafe():
       f.write("""if (!unsafe_es3_apis_enabled())
           return error::kUnknownCommand;
         """)
     f.write("""const gles2::cmds::%(name)s& c =
           *static_cast<const gles2::cmds::%(name)s*>(cmd_data);
       (void)c;
       """ % {'name': func.name})
 
-  def WriteServiceImplementation(self, func, f):
-    """Writes the service implementation for a command."""
-    self.WriteServiceHandlerFunctionHeader(func, f)
-    self.WriteHandlerExtensionCheck(func, f)
-    self.WriteHandlerDeferReadWrite(func, f);
+  def WriteServiceHandlerArgGetCode(self, func, f):
+    """Writes the argument unpack code for service handlers."""
     if len(func.GetOriginalArgs()) > 0:
       last_arg = func.GetLastOriginalArg()
       all_but_last_arg = func.GetOriginalArgs()[:-1]
       for arg in all_but_last_arg:
         arg.WriteGetCode(f)
       self.WriteGetDataSizeCode(func, f)
       last_arg.WriteGetCode(f)
+
+  def WriteImmediateServiceHandlerArgGetCode(self, func, f):
+    """Writes the argument unpack code for immediate service handlers."""
+    for arg in func.GetOriginalArgs():
+      if arg.IsPointer():
+        self.WriteGetDataSizeCode(func, f)
+      arg.WriteGetCode(f)
+
+  def WriteBucketServiceHandlerArgGetCode(self, func, f):
+    """Writes the argument unpack code for bucket service handlers."""
+    for arg in func.GetCmdArgs():
+      arg.WriteGetCode(f)
+
+  def WriteServiceImplementation(self, func, f):
+    """Writes the service implementation for a command."""
+    self.WriteServiceHandlerFunctionHeader(func, f)
+    self.WriteHandlerExtensionCheck(func, f)
+    self.WriteHandlerDeferReadWrite(func, f);
+    self.WriteServiceHandlerArgGetCode(func, f)
     func.WriteHandlerValidation(f)
     func.WriteHandlerImplementation(f)
     f.write("  return error::kNoError;\n")
     f.write("}\n")
     f.write("\n")
 
   def WriteImmediateServiceImplementation(self, func, f):
     """Writes the service implementation for an immediate version of command."""
     self.WriteServiceHandlerFunctionHeader(func, f)
     self.WriteHandlerExtensionCheck(func, f)
     self.WriteHandlerDeferReadWrite(func, f);
-    for arg in func.GetOriginalArgs():
-      if arg.IsPointer():
-        self.WriteGetDataSizeCode(func, f)
-      arg.WriteGetCode(f)
+    self.WriteImmediateServiceHandlerArgGetCode(func, f)
     func.WriteHandlerValidation(f)
     func.WriteHandlerImplementation(f)
     f.write("  return error::kNoError;\n")
     f.write("}\n")
     f.write("\n")
 
   def WriteBucketServiceImplementation(self, func, f):
     """Writes the service implementation for a bucket version of command."""
     self.WriteServiceHandlerFunctionHeader(func, f)
     self.WriteHandlerExtensionCheck(func, f)
     self.WriteHandlerDeferReadWrite(func, f);
-    for arg in func.GetCmdArgs():
-      arg.WriteGetCode(f)
+    self.WriteBucketServiceHandlerArgGetCode(func, f)
     func.WriteHandlerValidation(f)
     func.WriteHandlerImplementation(f)
     f.write("  return error::kNoError;\n")
     f.write("}\n")
     f.write("\n")
 
+  def WritePassthroughServiceFunctionHeader(self, func, f):
+    """Writes function header for service passthrough handlers."""
+    f.write("""error::Error GLES2DecoderPassthroughImpl::Handle%(name)s(
+        uint32_t immediate_data_size, const void* cmd_data) {
+      """ % {'name': func.name})
+    f.write("""const gles2::cmds::%(name)s& c =
+          *static_cast<const gles2::cmds::%(name)s*>(cmd_data);
+      (void)c;
+      """ % {'name': func.name})
+
+  def WritePassthroughServiceFunctionDoerCall(self, func, f):
+    """Writes the function call to the passthrough service doer."""
+    f.write("""  error::Error error = Do%(name)s(%(args)s);
+  if (error != error::kNoError) {
+    return error;
+  }""" % {'name': func.original_name,
+          'args': func.MakePassthroughServiceDoerArgString("")})
+
+  def WritePassthroughServiceImplementation(self, func, f):
+    """Writes the service implementation for a command."""
+    self.WritePassthroughServiceFunctionHeader(func, f)

[piman, 2016/05/25 23:34:42]

I see that you don't have an extension check here. Does that mean that if ANGLE
doesn't support a given extension (e.g. because the underlying GL/DX driver
doesn't support it), it will still accept the function calls given by that
extension, but just maybe fail them (e.g. with a GL error, or a lost context)?
It means we change from a command buffer error (error::kUnknownCommand) to a GL
error, but I think that's acceptable. I just want to make sure this is the
intent, and not an oversight.

[Geoff Lang, 2016/05/27 14:31:28]

I think we can continue to report command errors in this case, but I'll probably
do it in the Doer functions.  Reporting GL errors opens up a whole new group of
security issues because it's undefined behavour to call an entry point for an
extension that isn't present (if the GetProcAdress call returns anything to
begin with).

+    self.WriteServiceHandlerArgGetCode(func, f)
+    self.WritePassthroughServiceFunctionDoerCall(func, f)
+    f.write("  return error::kNoError;\n")
+    f.write("}\n")
+    f.write("\n")
+
+  def WritePassthroughImmediateServiceImplementation(self, func, f):
+    """Writes the service implementation for a command."""
+    self.WritePassthroughServiceFunctionHeader(func, f)
+    self.WriteImmediateServiceHandlerArgGetCode(func, f)
+    self.WritePassthroughServiceFunctionDoerCall(func, f)
+    f.write("  return error::kNoError;\n")
+    f.write("}\n")
+    f.write("\n")
+
+  def WritePassthroughBucketServiceImplementation(self, func, f):
+    """Writes the service implementation for a command."""
+    self.WritePassthroughServiceFunctionHeader(func, f)
+    self.WriteBucketServiceHandlerArgGetCode(func, f)
+    self.WritePassthroughServiceFunctionDoerCall(func, f)
+    f.write("  return error::kNoError;\n")
+    f.write("}\n")
+    f.write("\n")
+
   def WriteHandlerExtensionCheck(self, func, f):
     if func.GetInfo('extension_flag'):
       f.write("  if (!features().%s) {\n" % func.GetInfo('extension_flag'))
       f.write("    return error::kUnknownCommand;")
       f.write("  }\n\n")
 
   def WriteHandlerDeferReadWrite(self, func, f):
     """Writes the code to handle deferring reads or writes."""
     defer_draws = func.GetInfo('defer_draws')
     defer_reads = func.GetInfo('defer_reads')
@@ skipping 644 matching lines @@
     pass
 
   def WriteImmediateServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteBucketServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     pass
 
+  def WritePassthroughServiceImplementation(self, func, f):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WritePassthroughImmediateServiceImplementation(self, func, f):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WritePassthroughBucketServiceImplementation(self, func, f):
+    """Overrriden from TypeHandler."""
+    pass
+
   def WriteServiceUnitTest(self, func, f, *extras):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteImmediateServiceUnitTest(self, func, f, *extras):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteImmediateCmdGetTotalSize(self, func, f):
     """Overrriden from TypeHandler."""
@@ skipping 222 matching lines @@
   def WriteImmediateServiceUnitTest(self, func, f, *extras):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteBucketServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     if ((not func.name == 'CompressedTexSubImage2DBucket') and
         (not func.name == 'CompressedTexSubImage3DBucket')):
       TypeHandler.WriteBucketServiceImplemenation(self, func, f)
 
+  def WritePassthroughBucketServiceImplementation(self, func, f):
+    """Overrriden from TypeHandler."""
+    if ((not func.name == 'CompressedTexSubImage2DBucket') and
+        (not func.name == 'CompressedTexSubImage3DBucket')):
+      TypeHandler.WritePassthroughBucketServiceImplementation(self, func, f)
 
 class BindHandler(TypeHandler):
   """Handler for glBind___ type functions."""
 
   def WriteServiceUnitTest(self, func, f, *extras):
     """Overrriden from TypeHandler."""
 
     if len(func.GetOriginalArgs()) == 1:
       valid_test = """
 TEST_P(%(test_name)s, %(name)sValidArgs) {
@@ skipping 587 matching lines @@
                (func.name, func.MakeCmdArgString("")))
     f.write('  GPU_CLIENT_LOG("returned " << client_id);\n')
     f.write("  CheckGLError();\n")
     if func.return_type == "GLsync":
       f.write("  return reinterpret_cast<GLsync>(client_id);\n")
     else:
       f.write("  return client_id;\n")
     f.write("}\n")
     f.write("\n")
 
+  def WritePassthroughServiceImplementation(self, func, f):
+    """Overrriden from TypeHandler."""
+    pass
 
 class DeleteHandler(TypeHandler):
   """Handler for glDelete___ single resource type functions."""
 
   def WriteServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     if func.IsUnsafe():
       TypeHandler.WriteServiceImplementation(self, func, f)
     # HandleDeleteShader and HandleDeleteProgram are manually written.
     pass
@@ skipping 276 matching lines @@
     f.write("      RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));\n")
     f.write("  EXPECT_EQ(0, memcmp(ids, ImmediateDataAddress(&cmd),\n")
     f.write("                      sizeof(ids)));\n")
     f.write("}\n")
     f.write("\n")
 
 
 class GETnHandler(TypeHandler):
   """Handler for GETn for glGetBooleanv, glGetFloatv, ... type functions."""
 
+  def InitFunction(self, func):
+    """Overrriden from TypeHandler."""
+    TypeHandler.InitFunction(self, func)
+
+    if func.name == 'GetSynciv':
+      return
+
+    arg_insert_point = len(func.passthrough_service_doer_args) - 1;
+    func.passthrough_service_doer_args.insert(
+        arg_insert_point, Argument('length', 'GLsizei*'))
+    func.passthrough_service_doer_args.insert(
+        arg_insert_point, Argument('bufsize', 'GLsizei'))
+
   def NeedsDataTransferFunction(self, func):
     """Overriden from TypeHandler."""
     return False
 
   def WriteServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     self.WriteServiceHandlerFunctionHeader(func, f)
     last_arg = func.GetLastOriginalArg()
     # All except shm_id and shm_offset.
     all_but_last_args = func.GetCmdArgs()[:-2]
@@ skipping 33 matching lines @@
      code = """  GLenum error = LOCAL_PEEK_GL_ERROR("%(func_name)s");
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
   }
   return error::kNoError;
 }
 
 """
     f.write(code % {'func_name': func.name})
 
+  def WritePassthroughServiceImplementation(self, func, f):
+    """Overrriden from TypeHandler."""
+    self.WritePassthroughServiceFunctionHeader(func, f)
+    last_arg = func.GetLastOriginalArg()
+    # All except shm_id and shm_offset.
+    all_but_last_args = func.GetCmdArgs()[:-2]
+    for arg in all_but_last_args:
+      arg.WriteGetCode(f)
+
+    code = """  unsigned int buffer_size = 0;
+  typedef cmds::%(func_name)s::Result Result;
+  Result* result = GetSharedMemoryAndSizeAs<Result*>(
+      c.%(last_arg_name)s_shm_id, c.%(last_arg_name)s_shm_offset,
+      &buffer_size);
+  %(last_arg_type)s %(last_arg_name)s = result ? result->GetData() : NULL;

[piman, 2016/05/25 23:34:42]

Is it the responsibility of the Do* function to check NULL? Is there a case
where NULL is valid? Otherwise, it would be useful I think to just report the
error in the generated code so that we don't miss it.

[Geoff Lang, 2016/05/27 14:31:28]

Good point, added the null check here.

+  GLsizei bufsize = Result::ComputeMaxResults(buffer_size);
+  GLsizei written_values = 0;
+  GLsizei* length = &written_values;
+"""
+    f.write(code % {
+        'last_arg_type': last_arg.type,
+        'last_arg_name': last_arg.name,
+        'func_name': func.name,
+      })
+
+    self.WritePassthroughServiceFunctionDoerCall(func, f)
+
+    code = """  if (written_values > bufsize) {

[piman, 2016/05/25 23:34:42]

Is the intent that the function will only write up to bufsize entries, but
report how much it would have written in *length?

[Geoff Lang, 2016/05/27 14:31:28]

Yes, exactly.

+    return error::kOutOfBounds;
+  }
+  result->SetNumResults(written_values);
+  return error::kNoError;
+}
+
+"""
+    f.write(code % {'func_name': func.name})
+
   def WriteGLES2Implementation(self, func, f):
     """Overrriden from TypeHandler."""
     impl_decl = func.GetInfo('impl_decl')
     if impl_decl == None or impl_decl == True:
       f.write("%s GLES2Implementation::%s(%s) {\n" %
                  (func.return_type, func.original_name,
                   func.MakeTypedOriginalArgString("")))
       f.write("  GPU_CLIENT_SINGLE_THREAD_CHECK();\n")
       func.WriteDestinationInitalizationValidation(f)
       self.WriteClientGLCallLog(func, f)
@@ skipping 1416 matching lines @@
 
 class IsHandler(TypeHandler):
   """Handler for glIs____ type and glGetError functions."""
 
   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'])
+    func.passthrough_service_doer_args.append(Argument('result', 'uint32_t*'))
 
   def WriteServiceUnitTest(self, func, f, *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_);"""
     if func.IsUnsafe():
@@ skipping 68 matching lines @@
   }
 """
     f.write(code % {'func_name': func.name})
     func.WriteHandlerValidation(f)
     f.write("  *result_dst = %s(%s);\n" %
             (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
     f.write("  return error::kNoError;\n")
     f.write("}\n")
     f.write("\n")
 
+  def WritePassthroughServiceImplementation(self, func, f):
+    """Overrriden from TypeHandler."""
+    self.WritePassthroughServiceFunctionHeader(func, f)
+    self.WriteServiceHandlerArgGetCode(func, f)
+
+    code = """  typedef cmds::%(func_name)s::Result Result;
+  Result* result = GetSharedMemoryAs<Result*>(
+      c.result_shm_id, c.result_shm_offset, sizeof(*result));
+  if (!result) {
+    return error::kOutOfBounds;
+  }
+"""
+    f.write(code % {'func_name': func.name})
+    self.WritePassthroughServiceFunctionDoerCall(func, f)
+    f.write("  return error::kNoError;\n")
+    f.write("}\n")
+    f.write("\n")
+
   def WriteGLES2Implementation(self, func, f):
     """Overrriden from TypeHandler."""
     impl_func = func.GetInfo('impl_func')
     if impl_func == None or impl_func == True:
       error_value = func.GetInfo("error_value") or "GL_FALSE"
       f.write("%s GLES2Implementation::%s(%s) {\n" %
                  (func.return_type, func.original_name,
                   func.MakeTypedOriginalArgString("")))
       f.write("  GPU_CLIENT_SINGLE_THREAD_CHECK();\n")
       self.WriteTraceEvent(func, f)
@@ skipping 169 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 """
     self.WriteValidUnitTest(func, f, invalid_test, *extras)
 
   def WriteServiceImplementation(self, func, f):
     """Overrriden from TypeHandler."""
     pass
 
+  def WritePassthroughServiceImplementation(self, func, f):
+    """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
   the 'cmd_buffer_functions.txt' f, mostly enums.
   """
 
   def __init__(self, info):
     assert not 'is_complete' in info or info['is_complete'] == True
@@ skipping 815 matching lines @@
     self.name = name
     self.original_name = info['original_name']
 
     self.original_args = self.ParseArgs(info['original_args'])
 
     if 'cmd_args' in info:
       self.args_for_cmds = self.ParseArgs(info['cmd_args'])
     else:
       self.args_for_cmds = self.original_args[:]
 
+    self.passthrough_service_doer_args = self.original_args[:]
+
     self.return_type = info['return_type']
     if self.return_type != 'void':
       self.return_arg = CreateArg(info['return_type'] + " result")
     else:
       self.return_arg = None
 
     self.num_pointer_args = sum(
       [1 for arg in self.args_for_cmds if arg.IsPointer()])
     if self.num_pointer_args > 0:
       for arg in reversed(self.original_args):
@@ skipping 137 matching lines @@
     return [arg for arg in self.args_for_cmds if arg.IsConstant()]
 
   def GetInitArgs(self):
     """Gets the init args for this function."""
     return self.init_args
 
   def GetOriginalArgs(self):
     """Gets the original arguments to this function."""
     return self.original_args
 
+  def GetPassthroughServiceDoerArgs(self):
+    """Gets the original arguments to this function."""
+    return self.passthrough_service_doer_args
+
   def GetLastOriginalArg(self):
     """Gets the last original argument to this function."""
     return self.original_args[len(self.original_args) - 1]
 
   def GetLastOriginalPointerArg(self):
     return self.last_original_pointer_arg
 
   def GetResourceIdArg(self):
     for arg in self.original_args:
       if hasattr(arg, 'resource_type'):
@@ skipping 14 matching lines @@
         ["%s %s%s" % (arg.type, prefix, arg.name) for arg in args])
     return self._MaybePrependComma(arg_string, add_comma)
 
   def MakeOriginalArgString(self, prefix, add_comma = False, separator = ", "):
     """Gets the list of arguments as they are in GL."""
     args = self.GetOriginalArgs()
     arg_string = separator.join(
         ["%s%s" % (prefix, arg.name) for arg in args])
     return self._MaybePrependComma(arg_string, add_comma)
 
+  def MakePassthroughServiceDoerArgString(self, prefix, add_comma = False,
+                                          separator = ", "):
+    """Gets the list of arguments as they are in used by the passthrough
+       service doer function."""
+    args = self.GetPassthroughServiceDoerArgs()
+    arg_string = separator.join(
+        ["%s%s" % (prefix, arg.name) for arg in args])
+    return self._MaybePrependComma(arg_string, add_comma)
+
   def MakeHelperArgString(self, prefix, add_comma = False, separator = ", "):
     """Gets a list of GL arguments after removing unneeded arguments."""
     args = self.GetOriginalArgs()
     arg_string = separator.join(
         ["%s%s" % (prefix, arg.name)
          for arg in args if not arg.IsConstant()])
     return self._MaybePrependComma(arg_string, add_comma)
 
   def MakeTypedPepperArgString(self, prefix):
     """Gets a list of arguments as they need to be for Pepper."""
@@ skipping 153 matching lines @@
     self.type_handler.WriteDocs(self, f)
 
   def WriteCmdHelper(self, f):
     """Writes the cmd's helper."""
     self.type_handler.WriteCmdHelper(self, f)
 
   def WriteServiceImplementation(self, f):
     """Writes the service implementation for a command."""
     self.type_handler.WriteServiceImplementation(self, f)
 
+  def WritePassthroughServiceImplementation(self, f):
+    """Writes the service implementation for a command."""
+    self.type_handler.WritePassthroughServiceImplementation(self, f)
+
   def WriteServiceUnitTest(self, f, *extras):
     """Writes the service implementation for a command."""
     self.type_handler.WriteServiceUnitTest(self, f, *extras)
 
   def WriteGLES2CLibImplementation(self, f):
     """Writes the GLES2 C Lib Implemention."""
     self.type_handler.WriteGLES2CLibImplementation(self, f)
 
   def WriteGLES2InterfaceHeader(self, f):
     """Writes the GLES2 Interface declaration."""
@@ skipping 104 matching lines @@
 
     Function.InitFunction(self)
 
   def IsImmediate(self):
     return True
 
   def WriteServiceImplementation(self, f):
     """Overridden from Function"""
     self.type_handler.WriteImmediateServiceImplementation(self, f)
 
+  def WritePassthroughServiceImplementation(self, f):
+    """Overridden from Function"""
+    self.type_handler.WritePassthroughImmediateServiceImplementation(self, f)
+
   def WriteHandlerImplementation(self, f):
     """Overridden from Function"""
     self.type_handler.WriteImmediateHandlerImplementation(self, f)
 
   def WriteServiceUnitTest(self, f, *extras):
     """Writes the service implementation for a command."""
     self.type_handler.WriteImmediateServiceUnitTest(self, f, *extras)
 
   def WriteValidationCode(self, f):
     """Overridden from Function"""
@@ skipping 55 matching lines @@
         new_args_for_cmds.append(new_arg)
 
     self.args_for_cmds = new_args_for_cmds
 
     Function.InitFunction(self)
 
   def WriteServiceImplementation(self, f):
     """Overridden from Function"""
     self.type_handler.WriteBucketServiceImplementation(self, f)
 
+  def WritePassthroughServiceImplementation(self, f):
+    """Overridden from Function"""
+    self.type_handler.WritePassthroughBucketServiceImplementation(self, f)
+
   def WriteHandlerImplementation(self, f):
     """Overridden from Function"""
     self.type_handler.WriteBucketHandlerImplementation(self, f)
 
   def WriteServiceUnitTest(self, f, *extras):
     """Overridden from Function"""
     self.type_handler.WriteBucketServiceUnitTest(self, f, *extras)
 
   def MakeOriginalArgString(self, prefix, add_comma = False, separator = ", "):
     """Overridden from Function"""
@@ skipping 628 matching lines @@
               return false;
               """ % capability)
       f.write("""    default:
       NOTREACHED();
       return false;
   }
 }
 """)
     self.generated_cpp_filenames.append(filename)
 
+  def WritePassthroughServiceImplementation(self, filename):
+    """Writes the passthrough service decorder implementation."""
+    comment = "// It is included by gles2_cmd_decoder_passthrough.cc\n"
+    with CHeaderWriter(filename, comment) as f:
+      for func in self.functions:
+        func.WritePassthroughServiceImplementation(f)
+    self.generated_cpp_filenames.append(filename)
+
   def WriteServiceUnitTests(self, filename_pattern):
     """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
       filename = filename_pattern % count
       comment = "// It is included by gles2_cmd_decoder_unittest_%d.cc\n" \
                 % count
@@ skipping 788 matching lines @@
   gen.WriteGLES2TraceImplementationHeader(
       "gpu/command_buffer/client/gles2_trace_implementation_autogen.h")
   gen.WriteGLES2TraceImplementation(
       "gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h")
   gen.WriteGLES2CLibImplementation(
     "gpu/command_buffer/client/gles2_c_lib_autogen.h")
   gen.WriteCmdHelperHeader(
     "gpu/command_buffer/client/gles2_cmd_helper_autogen.h")
   gen.WriteServiceImplementation(
     "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h")
+  gen.WritePassthroughServiceImplementation(
+    "gpu/command_buffer/service/" +
+    "gles2_cmd_decoder_passthrough_handlers_autogen.h")
   gen.WriteServiceContextStateHeader(
     "gpu/command_buffer/service/context_state_autogen.h")
   gen.WriteServiceContextStateImpl(
     "gpu/command_buffer/service/context_state_impl_autogen.h")
   gen.WriteClientContextStateHeader(
     "gpu/command_buffer/client/client_context_state_autogen.h")
   gen.WriteClientContextStateImpl(
       "gpu/command_buffer/client/client_context_state_impl_autogen.h")
   gen.WriteServiceUnitTests(
     "gpu/command_buffer/service/gles2_cmd_decoder_unittest_%d_autogen.h")
@@ skipping 18 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:]))