command_buffer: infer all generated c/c++ source files to clang-format

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 7352 matching lines @@
 
   _function_re = re.compile(r'GL_APICALL(.*?)GL_APIENTRY (.*?) \((.*?)\);')
 
   def __init__(self, verbose):
     self.original_functions = []
     self.functions = []
     self.verbose = verbose
     self.errors = 0
     self.pepper_interfaces = []
     self.interface_info = {}
+    self.generated_cpp_filenames = []
 
     for interface in _PEPPER_INTERFACES:
       interface = PepperInterface(interface)
       self.pepper_interfaces.append(interface)
       self.interface_info[interface.GetName()] = interface
 
   def AddFunction(self, func):
     """Adds a function."""
     self.functions.append(func)
 
@@ skipping 104 matching lines @@
     file.Write("enum CommandId {\n")
     file.Write("  kStartPoint = cmd::kLastCommonId,  "
                "// All GLES2 commands start after this.\n")
     file.Write("#define GLES2_CMD_OP(name) k ## name,\n")
     file.Write("  GLES2_COMMAND_LIST(GLES2_CMD_OP)\n")
     file.Write("#undef GLES2_CMD_OP\n")
     file.Write("  kNumCommands\n")
     file.Write("};\n")
     file.Write("\n")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteFormat(self, filename):
     """Writes the command buffer format"""
     file = CHeaderWriter(filename)
     for func in self.functions:
       if True:
       #gen_cmd = func.GetInfo('gen_cmd')
       #if gen_cmd == True or gen_cmd == None:
         func.WriteStruct(file)
     file.Write("\n")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteDocs(self, filename):
     """Writes the command buffer doc version of the commands"""
     file = CWriter(filename)
     for func in self.functions:
       if True:
       #gen_cmd = func.GetInfo('gen_cmd')
       #if gen_cmd == True or gen_cmd == None:
         func.WriteDocs(file)
     file.Write("\n")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteFormatTest(self, filename):
     """Writes the command buffer format test."""
     file = CHeaderWriter(
       filename,
       "// This file contains unit tests for gles2 commmands\n"
       "// It is included by gles2_cmd_format_test.cc\n"
       "\n")
 
     for func in self.functions:
       if True:
       #gen_cmd = func.GetInfo('gen_cmd')
       #if gen_cmd == True or gen_cmd == None:
         func.WriteFormatTest(file)
 
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteCmdHelperHeader(self, filename):
     """Writes the gles2 command helper."""
     file = CHeaderWriter(filename)
 
     for func in self.functions:
       if True:
       #gen_cmd = func.GetInfo('gen_cmd')
       #if gen_cmd == True or gen_cmd == None:
         func.WriteCmdHelper(file)
 
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteServiceContextStateHeader(self, filename):
     """Writes the service context state header."""
     file = CHeaderWriter(
         filename,
         "// It is included by context_state.h\n")
     file.Write("struct EnableFlags {\n")
     file.Write("  EnableFlags();\n")
     for capability in _CAPABILITY_FLAGS:
       file.Write("  bool %s;\n" % capability['name'])
@@ skipping 40 matching lines @@
               return;
           }
           if (enable)
             glEnable(cap);
           else
             glDisable(cap);
         }
         """)
 
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteClientContextStateHeader(self, filename):
     """Writes the client context state header."""
     file = CHeaderWriter(
         filename,
         "// It is included by client_context_state.h\n")
     file.Write("struct EnableFlags {\n")
     file.Write("  EnableFlags();\n")
     for capability in _CAPABILITY_FLAGS:
       file.Write("  bool %s;\n" % capability['name'])
     file.Write("};\n\n")
 
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteContextStateGetters(self, file, class_name):
     """Writes the state getters."""
     for gl_type in ["GLint", "GLfloat"]:
       file.Write("""
 bool %s::GetStateAs%s(
     GLenum pname, %s* params, GLsizei* num_written) const {
   switch (pname) {
 """ % (class_name, gl_type, gl_type))
       for state_name in sorted(_STATES.keys()):
@@ skipping 188 matching lines @@
       file.Write("      return enable_flags.%s;\n" % capability['name'])
     file.Write("""    default:
       NOTREACHED();
       return false;
   }
 }
 """)
 
     self.WriteContextStateGetters(file, "ContextState")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteClientContextStateImpl(self, filename):
     """Writes the context state client side implementation."""
     file = CHeaderWriter(
         filename,
         "// It is included by client_context_state.cc\n")
     code = []
     for capability in _CAPABILITY_FLAGS:
       code.append("%s(%s)" %
                   (capability['name'],
@@ skipping 29 matching lines @@
     for capability in _CAPABILITY_FLAGS:
       file.Write("    case GL_%s:\n" % capability['name'].upper())
       file.Write("      *enabled = enable_flags.%s;\n" % capability['name'])
       file.Write("      return true;\n")
     file.Write("""    default:
       return false;
   }
 }
 """)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteServiceImplementation(self, filename):
     """Writes the service decorder implementation."""
     file = CHeaderWriter(
         filename,
         "// It is included by gles2_cmd_decoder.cc\n")
 
     for func in self.functions:
       if True:
       #gen_cmd = func.GetInfo('gen_cmd')
@@ skipping 26 matching lines @@
             }
             return false;
             """ % capability)
     file.Write("""    default:
       NOTREACHED();
       return false;
   }
 }
 """)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteServiceUnitTests(self, filename):
     """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(
@@ skipping 14 matching lines @@
 
         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, {
               'test_name': test_name
             })
-
       file.Close()
+      self.generated_cpp_filenames.append(file.filename)
     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" %
                  (capability['name'].upper(),
                   ('false', 'true')['default' in capability]))
@@ skipping 55 matching lines @@
         args = ["_" if isinstance(arg, list) else arg for arg in args]
         file.Write("  EXPECT_CALL(*gl_, %s(%s))\n" %
                    (state['func'], ", ".join(args)))
         file.Write("      .Times(1)\n")
         file.Write("      .RetiresOnSaturation();\n")
         if 'extension_flag' in state:
           file.Write("  }\n")
     file.Write("""}
 """)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   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()
+    self.generated_cpp_filenames.append(file.filename)
 
   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")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2CLibImplementation(self, filename):
     """Writes the GLES2 c lib implementation."""
     file = CHeaderWriter(
         filename,
         "// These functions emulate GLES2 over command buffers.\n")
 
     for func in self.original_functions:
       func.WriteGLES2CLibImplementation(file)
 
     file.Write("""
 namespace gles2 {
 
 extern const NameToFunc g_gles2_function_table[] = {
 """)
     for func in self.original_functions:
       file.Write(
           '  { "gl%s", reinterpret_cast<GLES2FunctionPointer>(gl%s), },\n' %
           (func.name, func.name))
     file.Write("""  { NULL, NULL, },
 };
 
 }  // namespace gles2
 """)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2InterfaceHeader(self, filename):
     """Writes the GLES2 interface header."""
     file = CHeaderWriter(
         filename,
         "// This file is included by gles2_interface.h to declare the\n"
         "// GL api functions.\n")
     for func in self.original_functions:
       func.WriteGLES2InterfaceHeader(file)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2InterfaceStub(self, filename):
     """Writes the GLES2 interface stub header."""
     file = CHeaderWriter(
         filename,
         "// This file is included by gles2_interface_stub.h.\n")
     for func in self.original_functions:
       func.WriteGLES2InterfaceStub(file)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2InterfaceStubImpl(self, filename):
     """Writes the GLES2 interface header."""
     file = CHeaderWriter(
         filename,
         "// This file is included by gles2_interface_stub.cc.\n")
     for func in self.original_functions:
       func.WriteGLES2InterfaceStubImpl(file)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2ImplementationHeader(self, filename):
     """Writes the GLES2 Implementation header."""
     file = CHeaderWriter(
         filename,
         "// This file is included by gles2_implementation.h to declare the\n"
         "// GL api functions.\n")
     for func in self.original_functions:
       func.WriteGLES2ImplementationHeader(file)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2Implementation(self, filename):
     """Writes the GLES2 Implementation."""
     file = CHeaderWriter(
         filename,
         "// This file is included by gles2_implementation.cc to define the\n"
         "// GL api functions.\n")
     for func in self.original_functions:
       func.WriteGLES2Implementation(file)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2TraceImplementationHeader(self, filename):
     """Writes the GLES2 Trace Implementation header."""
     file = CHeaderWriter(
         filename,
         "// This file is included by gles2_trace_implementation.h\n")
     for func in self.original_functions:
       func.WriteGLES2TraceImplementationHeader(file)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2TraceImplementation(self, filename):
     """Writes the GLES2 Trace Implementation."""
     file = CHeaderWriter(
         filename,
         "// This file is included by gles2_trace_implementation.cc\n")
     for func in self.original_functions:
       func.WriteGLES2TraceImplementation(file)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2ImplementationUnitTests(self, filename):
     """Writes the GLES2 helper header."""
     file = CHeaderWriter(
         filename,
         "// This file is included by gles2_implementation.h to declare the\n"
         "// GL api functions.\n")
     for func in self.original_functions:
       func.WriteGLES2ImplementationUnitTest(file)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteServiceUtilsHeader(self, filename):
     """Writes the gles2 auto generated utility header."""
     file = CHeaderWriter(filename)
     for name in sorted(_NAMED_TYPE_INFO.keys()):
       named_type = NamedType(_NAMED_TYPE_INFO[name])
       if named_type.IsConstant():
         continue
       file.Write("ValueValidator<%s> %s;\n" %
                  (named_type.GetType(), ToUnderscore(name)))
     file.Write("\n")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteServiceUtilsImplementation(self, filename):
     """Writes the gles2 auto generated utility implementation."""
     file = CHeaderWriter(filename)
     names = sorted(_NAMED_TYPE_INFO.keys())
     for name in names:
       named_type = NamedType(_NAMED_TYPE_INFO[name])
       if named_type.IsConstant():
         continue
       if named_type.GetValidValues():
@@ skipping 15 matching lines @@
       else:
         code = "%(pre)s%(name)s()"
       file.Write(code % {
         'name': ToUnderscore(name),
         'pre': pre,
       })
       pre = ',\n    '
     file.Write(" {\n");
     file.Write("}\n\n");
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteCommonUtilsHeader(self, filename):
     """Writes the gles2 common utility header."""
     file = CHeaderWriter(filename)
     type_infos = sorted(_NAMED_TYPE_INFO.keys())
     for type_info in type_infos:
       if _NAMED_TYPE_INFO[type_info]['type'] == 'GLenum':
         file.Write("static std::string GetString%s(uint32_t value);\n" %
                    type_info)
     file.Write("\n")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteCommonUtilsImpl(self, filename):
     """Writes the gles2 common utility header."""
     enum_re = re.compile(r'\#define\s+(GL_[a-zA-Z0-9_]+)\s+([0-9A-Fa-fx]+)')
     dict = {}
-    for fname in ['../../third_party/khronos/GLES2/gl2.h',
-                  '../../third_party/khronos/GLES2/gl2ext.h',
-                  '../../gpu/GLES2/gl2chromium.h',
-                  '../../gpu/GLES2/gl2extchromium.h']:
+    for fname in ['third_party/khronos/GLES2/gl2.h',
+                  'third_party/khronos/GLES2/gl2ext.h',
+                  'gpu/GLES2/gl2chromium.h',
+                  'gpu/GLES2/gl2extchromium.h']:
       lines = open(fname).readlines()
       for line in lines:
         m = enum_re.match(line)
         if m:
           name = m.group(1)
           value = m.group(2)
           if len(value) <= 10 and not value in dict:
             dict[value] = name
 
     file = CHeaderWriter(filename)
@@ skipping 25 matching lines @@
 }
 
 """)
         else:
           file.Write("""  return GLES2Util::GetQualifiedEnumString(
       NULL, 0, value);
 }
 
 """)
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WritePepperGLES2Interface(self, filename, dev):
     """Writes the Pepper OpenGLES interface definition."""
     file = CWriter(filename)
     file.Write(_LICENSE)
     file.Write(_DO_NOT_EDIT_WARNING)
 
     file.Write("label Chrome {\n")
     file.Write("  M39 = 1.0\n")
     file.Write("};\n\n")
@@ skipping 122 matching lines @@
         f.GetPepperName() for f in self.original_functions
           if f.InPepperInterface(interface)))
       file.Write("\n")
 
       file.Write("  };\n")
       file.Write("  return &ppb_opengles2;\n")
       file.Write("}\n")
 
     file.Write("}  // namespace ppapi\n")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteGLES2ToPPAPIBridge(self, filename):
     """Connects GLES2 helper library to PPB_OpenGLES2 interface"""
 
     file = CWriter(filename)
     file.Write(_LICENSE)
     file.Write(_DO_NOT_EDIT_WARNING)
 
     file.Write("#ifndef GL_GLEXT_PROTOTYPES\n")
     file.Write("#define GL_GLEXT_PROTOTYPES\n")
@@ skipping 25 matching lines @@
         file.Write("  if (ext)\n")
         file.Write("    %sext->%s(%s);\n" %
                    (return_str, func.GetPepperName(), arg))
         if return_str:
           file.Write("  %s0;\n" % return_str)
       else:
         file.Write("  %s%s->%s(%s);\n" %
                    (return_str, interface_str, func.GetPepperName(), arg))
       file.Write("}\n\n")
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteMojoGLCallVisitor(self, filename):
     """Provides the GL implementation for mojo"""
     file = CWriter(filename)
     file.Write(_LICENSE)
     file.Write(_DO_NOT_EDIT_WARNING)
 
     for func in self.original_functions:
       if not func.IsCoreGLFunction():
         continue
       file.Write("VISIT_GL_CALL(%s, %s, (%s), (%s))\n" %
                              (func.name, func.return_type,
                               func.MakeTypedOriginalArgString(""),
                               func.MakeOriginalArgString("")))
 
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
   def WriteMojoGLCallVisitorForExtension(self, filename, extension):
     """Provides the GL implementation for mojo for a particular extension"""
     file = CWriter(filename)
     file.Write(_LICENSE)
     file.Write(_DO_NOT_EDIT_WARNING)
 
     for func in self.original_functions:
       if func.GetInfo("extension") != extension:
         continue
       file.Write("VISIT_GL_CALL(%s, %s, (%s), (%s))\n" %
                              (func.name, func.return_type,
                               func.MakeTypedOriginalArgString(""),
                               func.MakeOriginalArgString("")))
 
     file.Close()
+    self.generated_cpp_filenames.append(file.filename)
 
 def Format(generated_files):
   for filename in generated_files:
     call(["clang-format", "-i", "-style=chromium", filename])
 
 def main(argv):
   """This is the main function."""
   parser = OptionParser()
   parser.add_option(
       "--output-dir",
@@ skipping 20 matching lines @@
           continue
         if not item['enum'] in gl_state_valid:
           gl_state_valid.append(item['enum'])
   for capability in _CAPABILITY_FLAGS:
     valid_value = "GL_%s" % capability['name'].upper()
     if not valid_value in gl_state_valid:
       gl_state_valid.append(valid_value)
 
   # This script lives under gpu/command_buffer, cd to base directory.
   os.chdir(os.path.dirname(__file__) + "/../..")
-
+  base_dir = os.getcwd()
   gen = GLGenerator(options.verbose)
   gen.ParseGLH("gpu/command_buffer/cmd_buffer_functions.txt")
 
   # Support generating files under gen/
   if options.output_dir != None:
     os.chdir(options.output_dir)
 
   gen.WritePepperGLES2Interface("ppapi/api/ppb_opengles2.idl", False)
   gen.WritePepperGLES2Interface("ppapi/api/dev/ppb_opengles2ext_dev.idl", True)
   gen.WriteGLES2ToPPAPIBridge("ppapi/lib/gl/gles2/gles2.c")
   gen.WritePepperGLES2Implementation(
       "ppapi/shared_impl/ppb_opengles2_shared.cc")
-  os.chdir("gpu/command_buffer")
-  gen.WriteCommandIds("common/gles2_cmd_ids_autogen.h")
-  gen.WriteFormat("common/gles2_cmd_format_autogen.h")
-  gen.WriteFormatTest("common/gles2_cmd_format_test_autogen.h")
-  gen.WriteGLES2InterfaceHeader("client/gles2_interface_autogen.h")
-  gen.WriteGLES2InterfaceStub("client/gles2_interface_stub_autogen.h")
+  os.chdir(base_dir)
+  gen.WriteCommandIds("gpu/command_buffer/common/gles2_cmd_ids_autogen.h")
+  gen.WriteFormat("gpu/command_buffer/common/gles2_cmd_format_autogen.h")
+  gen.WriteFormatTest(
+    "gpu/command_buffer/common/gles2_cmd_format_test_autogen.h")
+  gen.WriteGLES2InterfaceHeader(
+    "gpu/command_buffer/client/gles2_interface_autogen.h")
+  gen.WriteGLES2InterfaceStub(
+    "gpu/command_buffer/client/gles2_interface_stub_autogen.h")
   gen.WriteGLES2InterfaceStubImpl(
-      "client/gles2_interface_stub_impl_autogen.h")
-  gen.WriteGLES2ImplementationHeader("client/gles2_implementation_autogen.h")
-  gen.WriteGLES2Implementation("client/gles2_implementation_impl_autogen.h")
+      "gpu/command_buffer/client/gles2_interface_stub_impl_autogen.h")
+  gen.WriteGLES2ImplementationHeader(
+    "gpu/command_buffer/client/gles2_implementation_autogen.h")
+  gen.WriteGLES2Implementation(
+    "gpu/command_buffer/client/gles2_implementation_impl_autogen.h")
   gen.WriteGLES2ImplementationUnitTests(
-      "client/gles2_implementation_unittest_autogen.h")
+      "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h")
   gen.WriteGLES2TraceImplementationHeader(
-      "client/gles2_trace_implementation_autogen.h")
+      "gpu/command_buffer/client/gles2_trace_implementation_autogen.h")
   gen.WriteGLES2TraceImplementation(
-      "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")
+      "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.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(
-      "client/client_context_state_impl_autogen.h")
-  gen.WriteServiceUnitTests("service/gles2_cmd_decoder_unittest_%d_autogen.h")
+      "gpu/command_buffer/client/client_context_state_impl_autogen.h")
+  gen.WriteServiceUnitTests(
+    "gpu/command_buffer/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")
+    "gpu/command_buffer/service/"
+    "gles2_cmd_decoder_unittest_extensions_autogen.h")
+  gen.WriteServiceUtilsHeader(
+    "gpu/command_buffer/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"
+    "gpu/command_buffer/service/"
+    "gles2_cmd_validation_implementation_autogen.h")
+  gen.WriteCommonUtilsHeader(
+    "gpu/command_buffer/common/gles2_cmd_utils_autogen.h")
+  gen.WriteCommonUtilsImpl(
+    "gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h")
+  gen.WriteGLES2Header("gpu/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",
       "CHROMIUM_texture_mailbox")
   gen.WriteMojoGLCallVisitorForExtension(
       mojo_gles2_prefix + "_chromium_sync_point_autogen.h",
       "CHROMIUM_sync_point")
 
-  Format([
-      "common/gles2_cmd_format_autogen.h",
-      "common/gles2_cmd_format_test_autogen.h",
-      "common/gles2_cmd_ids_autogen.h",
-      "common/gles2_cmd_utils_autogen.h",
-      "common/gles2_cmd_utils_implementation_autogen.h",
-      "client/client_context_state_autogen.h",
-      "client/client_context_state_impl_autogen.h",
-      "client/gles2_cmd_helper_autogen.h",
-      "client/gles2_c_lib_autogen.h",
-      "client/gles2_implementation_autogen.h",
-      "client/gles2_implementation_impl_autogen.h",
-      "client/gles2_implementation_unittest_autogen.h",
-      "client/gles2_interface_autogen.h",
-      "client/gles2_interface_stub_autogen.h",
-      "client/gles2_interface_stub_impl_autogen.h",
-      "client/gles2_trace_implementation_autogen.h",
-      "client/gles2_trace_implementation_impl_autogen.h",
-      "service/context_state_autogen.h",
-      "service/context_state_impl_autogen.h",
-      "service/gles2_cmd_decoder_autogen.h",
-      "service/gles2_cmd_decoder_unittest_0_autogen.h",
-      "service/gles2_cmd_decoder_unittest_1_autogen.h",
-      "service/gles2_cmd_decoder_unittest_2_autogen.h",
-      "service/gles2_cmd_decoder_unittest_3_autogen.h",
-      "service/gles2_cmd_validation_autogen.h",
-      "service/gles2_cmd_validation_implementation_autogen.h"])
-  os.chdir("../..")
-  mojo_gles2_prefix = "mojo/public/c/gles2/gles2_call_visitor"
-  Format([
-      "gpu/GLES2/gl2chromium_autogen.h",
-      mojo_gles2_prefix + "_autogen.h",
-      mojo_gles2_prefix + "_chromium_texture_mailbox_autogen.h",
-      mojo_gles2_prefix + "_chromium_sync_point_autogen.h",
-      "ppapi/lib/gl/gles2/gles2.c",
-      "ppapi/shared_impl/ppb_opengles2_shared.cc"])
+  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:]))