Add Pepper support for several GL extensions

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """code generator for GLES2 command buffers."""
 
 import os
 import os.path
 import sys
@@ skipping 713 matching lines @@
     'type': 'GLboolean',
     'valid': [
       'false',
     ],
     'invalid': [
       'true',
     ],
   },
 }
 
+# This table specifies the different pepper interfaces that are supported for
+# GL commands. The first part of the tuple is the name, and the second part is
+# whether it's a dev interface.
+_PEPPER_INTERFACES = [
+  ('', False),

[greggman, 2012/02/22 00:53:05]

You can leave this as is but my preference would be to label fields. 

_PEPPER_INTERFACES = [
{'name': Foo, 'dev': True},
...
];

+  ('InstancedArrays', True),
+  ('FramebufferBlit', True),
+  ('FramebufferMultisample', True),
+  ('ChromiumEnableFeature', True),
+  ('ChromiumMapSub', True),
+]
+
 # This table specifies types and other special data for the commands that
 # will be generated.
 #
 # cmd_comment:  A comment added to the cmd format.
 # type:         defines which handler will be used to generate code.
 # decoder_func: defines which function to call in the decoder to execute the
 #               corresponding GL command. If not specified the GL command will
 #               be called directly.
 # gl_test_func: GL function that is expected to be called when testing.
 # cmd_args:     The arguments to use for the command. This overrides generating
@@ skipping 12 matching lines @@
 # needs_size:   If true a data_size field is added to the command.
 # data_type:    The type of data the command uses. For PUTn or PUT types.
 # count:        The number of units per element. For PUTn or PUT types.
 # unit_test:    If False no service side unit test will be generated.
 # client_test:  If False no client side unit test will be generated.
 # expectation:  If False the unit test will have no expected calls.
 # gen_func:     Name of function that generates GL resource for corresponding
 #               bind function.
 # valid_args:   A dictionary of argument indices to args to use in unit tests
 #               when they can not be automatically determined.
+# pepper_interface: The pepper interface that is used for this extension
 
 _FUNCTION_INFO = {
   'ActiveTexture': {
     'decoder_func': 'DoActiveTexture',
     'unit_test': False,
     'impl_func': False,
     'client_test': False,
   },
   'AttachShader': {'decoder_func': 'DoAttachShader'},
   'BindAttribLocation': {'type': 'GLchar', 'bucket': True, 'needs_size': True},
@@ skipping 16 matching lines @@
   },
   'BindTexture': {
     'type': 'Bind',
     'decoder_func': 'DoBindTexture',
     'gen_func': 'GenTextures',
   },
   'BlitFramebufferEXT': {
     'decoder_func': 'DoBlitFramebufferEXT',
     'unit_test': False,
     'extension': True,
+    'pepper_interface': 'FramebufferBlit',
   },
   'BufferData': {
     'type': 'Manual',
     'immediate': True,
     'client_test': False,
   },
   'BufferSubData': {
     'type': 'Data',
     'client_test': False,
     'decoder_func': 'DoBufferSubData',
@@ skipping 15 matching lines @@
   'ClearStencil': {'decoder_func': 'DoClearStencil'},
   'EnableFeatureCHROMIUM': {
     'type': 'Custom',
     'immediate': False,
     'decoder_func': 'DoEnableFeatureCHROMIUM',
     'expectation': False,
     'cmd_args': 'GLuint bucket_id, GLint* result',
     'result': ['GLint'],
     'extension': True,
     'chromium': True,
+    'pepper_interface': 'ChromiumEnableFeature',
   },
   'CompileShader': {'decoder_func': 'DoCompileShader', 'unit_test': False},
   'CompressedTexImage2D': {
     'type': 'Manual',
     'immediate': True,
     'bucket': True,
   },
   'CompressedTexSubImage2D': {
     'type': 'Data',
     'bucket': True,
@@ skipping 333 matching lines @@
   },
   'LinkProgram': {
     'decoder_func': 'DoLinkProgram',
     'impl_func':  False,
   },
   'MapBufferSubDataCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
     'client_test': False,
+    'pepper_interface': 'ChromiumMapSub',
   },
   'MapTexSubImage2DCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
     'client_test': False,
+    'pepper_interface': 'ChromiumMapSub',
   },
   'PixelStorei': {'type': 'Manual'},
   'PostSubBufferCHROMIUM': {
       'type': 'Custom',
       'impl_func': False,
       'unit_test': False,
       'client_test': False,
       'extension': True,
       'chromium': True,
   },
   'RenderbufferStorage': {
     'decoder_func': 'DoRenderbufferStorage',
     'gl_test_func': 'glRenderbufferStorageEXT',
     'expectation': False,
   },
   'RenderbufferStorageMultisampleEXT': {
     'decoder_func': 'DoRenderbufferStorageMultisample',
     'gl_test_func': 'glRenderbufferStorageMultisampleEXT',
     'expectation': False,
     'unit_test': False,
     'extension': True,
+    'pepper_interface': 'FramebufferMultisample',
   },
   'ReadPixels': {
     'cmd_comment':
         '// ReadPixels has the result separated from the pixel buffer so that\n'
         '// it is easier to specify the result going to some specific place\n'
         '// that exactly fits the rectangle of pixels.\n',
     'type': 'Custom',
     'immediate': False,
     'impl_func': False,
     'client_test': False,
@@ skipping 155 matching lines @@
     'type': 'PUTn',
     'data_type': 'GLfloat',
     'count': 16,
     'decoder_func': 'DoUniformMatrix4fv',
   },
   'UnmapBufferSubDataCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
     'client_test': False,
-    },
+    'pepper_interface': 'ChromiumMapSub',
+  },
   'UnmapTexSubImage2DCHROMIUM': {
     'gen_cmd': False,
     'extension': True,
     'chromium': True,
     'client_test': False,
+    'pepper_interface': 'ChromiumMapSub',
   },
   'UseProgram': {'decoder_func': 'DoUseProgram', 'unit_test': False},
   'ValidateProgram': {'decoder_func': 'DoValidateProgram'},
   'VertexAttrib1f': {'decoder_func': 'DoVertexAttrib1f'},
   'VertexAttrib1fv': {
     'type': 'PUT',
     'data_type': 'GLfloat',
     'count': 1,
     'decoder_func': 'DoVertexAttrib1fv',
   },
@@ skipping 83 matching lines @@
     'unit_test': False,
     'extension': True,
     'decoder_func': 'DoTexStorage2DEXT',
   },
   'DrawArraysInstancedANGLE': {
     'type': 'Manual',
     'cmd_args': 'GLenumDrawMode mode, GLint first, GLsizei count, '
                 'GLsizei primcount',
     'extension': True,
     'unit_test': False,
+    'pepper_interface': 'InstancedArrays',
   },
   'DrawElementsInstancedANGLE': {
     'type': 'Manual',
     'cmd_args': 'GLenumDrawMode mode, GLsizei count, '
                 'GLenumIndexType type, GLuint index_offset, GLsizei primcount',
     'extension': True,
     'unit_test': False,
     'client_test': False,
+    'pepper_interface': 'InstancedArrays',
   },
   'VertexAttribDivisorANGLE': {
     'type': 'Manual',
     'cmd_args': 'GLuint index, GLuint divisor',
     'extension': True,
     'unit_test': False,
+    'pepper_interface': 'InstancedArrays',
   },
 
 }
 
 
 def SplitWords(input_string):
   """Transforms a input_string into a list of lower-case components.
 
   Args:
     input_string: the input string.
@@ skipping 70 matching lines @@
                 not parts[ii][0] == ")" and not fptr.match(parts[ii]))
             and splitter < 80):
           return splitter
         splitter += len(parts[ii]) + 1
     done = False
     end = len(string)
     last_splitter = -1
     while not done:
       splitter = string[0:end].rfind(',')
       if splitter < 0 or (splitter > 0 and string[splitter - 1] == '"'):
+        if last_splitter == -1:
+          break
+        return last_splitter
+      elif splitter >= 80:
+        end = splitter
+      else:
+        return splitter
+    end = len(string)
+    last_splitter = -1
+    while not done:
+      splitter = string[0:end].rfind(' ')
+      if splitter < 0 or (splitter > 0 and string[splitter - 1] == '"'):
         return last_splitter
       elif splitter >= 80:
         end = splitter
       else:
         return splitter
 
   def __WriteLine(self, line, ends_with_eol):
     """Given a signle line, writes it to a file, splitting if it's > 80 chars"""
     if len(line) >= 80:
       i = self.__FindSplit(line)
       if i > 0:
         line1 = line[0:i + 1]
+        if line1[-1] == ' ':
+          line1 = line1[:-1]
+        lineend = ''
+        if line1[0] == '#':
+          lineend = ' \\'
         nolint = ''
         if len(line1) > 80:
           nolint = '  // NOLINT'
-        self.__AddLine(line1 + nolint + '\n')
+        self.__AddLine(line1 + nolint + lineend + '\n')
         match = re.match("( +)", line1)
         indent = ""
         if match:
           indent = match.group(1)
         splitter = line[i]
         if not splitter == ',':
           indent = "    " + indent
         self.__WriteLine(indent + line[i + 1:].lstrip(), True)
         return
     nolint = ''
@@ skipping 3302 matching lines @@
       return valid_args[str(index)]
     return None
 
   def AddInfo(self, name, value):
     """Adds an info."""
     setattr(self.info, name, value)
 
   def IsCoreGLFunction(self):
     return not self.GetInfo('extension')
 
+  def InPepperInterface(self, interface):
+    ext = self.GetInfo('pepper_interface')
+    if not interface.GetName():
+      return self.IsCoreGLFunction()
+    return ext == interface.GetName()
+
+  def InAnyPepperExtension(self):
+    return self.IsCoreGLFunction() or self.GetInfo('pepper_interface')
+
   def GetGLFunctionName(self):
     """Gets the function to call to execute GL for this command."""
     if self.GetInfo('decoder_func'):
       return self.GetInfo('decoder_func')
     return "gl%s" % self.original_name
 
   def GetGLTestFunctionName(self):
     gl_func_name = self.GetInfo('gl_test_func')
     if gl_func_name == None:
       gl_func_name = self.GetGLFunctionName()
@@ skipping 168 matching lines @@
     """Writes the GLES2 Implemention unit test."""
     self.type_handler.WriteGLES2ImplementationUnitTest(self, file)
 
   def WriteDestinationInitalizationValidation(self, file):
     """Writes the client side destintion initialization validation."""
     self.type_handler.WriteDestinationInitalizationValidation(self, file)
 
   def WriteFormatTest(self, file):
     """Writes the cmd's format test."""
     self.type_handler.WriteFormatTest(self, file)
 

[greggman, 2012/02/22 00:53:05]

style: 2 blank lines between top level definitions

+class PepperInterface(object):
+  """A class that represents a function."""
+
+  def __init__(self, (name, dev)):
+    self.name = name
+    self.dev = dev
+
+  def GetName(self):
+    return self.name
+
+  def GetInterfaceName(self):
+    upperint = ""
+    dev = ""
+    if self.name:
+      upperint = "_" + self.name.upper()
+    if self.dev:
+      dev = "_DEV"
+    return "PPB_OPENGLES2%s%s_INTERFACE" % (upperint, dev)
+
+  def GetInterfaceString(self):
+    dev = ""
+    if self.dev:
+      dev = "(Dev)"
+    return "PPB_OpenGLES2%s%s" % (self.name, dev)
+
+  def GetStructName(self):
+    dev = ""
+    if self.dev:
+      dev = "_Dev"
+    return "PPB_OpenGLES2%s%s" % (self.name, dev)
 

[greggman, 2012/02/22 00:53:05]

style: 2 blank lines between top level definitions

 class ImmediateFunction(Function):
   """A class that represnets an immediate function command."""
 
   def __init__(self, func):
     new_args = []
     for arg in func.GetOriginalArgs():
       new_arg = arg.GetImmediateVersion()
       if new_arg:
         new_args.append(new_arg)
 
@@ skipping 178 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._function_info = {}
     self._empty_type_handler = TypeHandler()
     self._empty_function_info = FunctionInfo({}, self._empty_type_handler)
+    self.pepper_interfaces = []
+    self.interface_info = {}
 
     self._type_handlers = {
       'Bind': BindHandler(),
       'Create': CreateHandler(),
       'Custom': CustomHandler(),
       'Data': DataHandler(),
       'Delete': DeleteHandler(),
       'DELn': DELnHandler(),
       'GENn': GENnHandler(),
       'GETn': GETnHandler(),
       'GLchar': GLcharHandler(),
       'HandWritten': HandWrittenHandler(),
       'Is': IsHandler(),
       'Manual': ManualHandler(),
       'PUT': PUTHandler(),
       'PUTn': PUTnHandler(),
       'PUTXn': PUTXnHandler(),
       'STRn': STRnHandler(),
       'Todo': TodoHandler(),
     }
 
     for func_name in _FUNCTION_INFO:
       info = _FUNCTION_INFO[func_name]
       type = ''
       if 'type' in info:
         type = info['type']
       self._function_info[func_name] = FunctionInfo(info,
                                                     self.GetTypeHandler(type))
+    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)
 
   def GetTypeHandler(self, name):
     """Gets a type info for the given type."""
     if name in self._type_handlers:
       return self._type_handlers[name]
     return self._empty_type_handler
@@ skipping 342 matching lines @@
 
 """)
         else:
           file.Write("""  return GLES2Util::GetQualifiedEnumString(
       NULL, 0, value);
 }
 
 """)
     file.Close()
 
-  def WritePepperGLES2Interface(self, filename):
+  def WritePepperGLES2Interface(self, filename, dev):
     """Writes the Pepper OpenGLES interface definition."""
     file = CHeaderWriter(
         filename,
         "// OpenGL ES interface.\n",
-        3)
+        2)
 
-    file.Write("#include \"ppapi/c/pp_resource.h\"\n\n")
+    file.Write("#include \"ppapi/c/pp_resource.h\"\n")
+    if dev:
+      file.Write("#include \"ppapi/c/ppb_opengles2.h\"\n\n")
+    else:
+      file.Write("\n#ifndef __gl2_h_\n")
+      for (k, v) in _GL_TYPES.iteritems():
+        file.Write("typedef %s %s;\n" % (v, k))
+      file.Write("#endif  // __gl2_h_\n\n")
 
-    file.Write("#ifndef __gl2_h_\n")
-    for (k, v) in _GL_TYPES.iteritems():
-      file.Write("typedef %s %s;\n" % (v, k))
-    file.Write("#endif  // __gl2_h_\n\n")
+    for interface in self.pepper_interfaces:
+      if interface.dev != dev:
+        continue
+      file.Write("#define %s_1_0 \"%s;1.0\"\n" %
+                 (interface.GetInterfaceName(), interface.GetInterfaceString()))
+      file.Write("#define %s %s_1_0\n" %
+                 (interface.GetInterfaceName(), interface.GetInterfaceName()))
 
-    file.Write("#define PPB_OPENGLES2_INTERFACE_1_0 \"PPB_OpenGLES2;1.0\"\n")
-    file.Write("#define PPB_OPENGLES2_INTERFACE PPB_OPENGLES2_INTERFACE_1_0\n")
+      file.Write("\nstruct %s {\n" % interface.GetStructName())
+      for func in self.original_functions:
+        if not func.InPepperInterface(interface):
+          continue
 
-    file.Write("\nstruct PPB_OpenGLES2 {\n")
-    for func in self.original_functions:
-      if not func.IsCoreGLFunction():
-        continue
+        original_arg = func.MakeTypedOriginalArgString("")
+        context_arg = "PP_Resource context"
+        if len(original_arg):
+          arg = context_arg + ", " + original_arg
+        else:
+          arg = context_arg
+        file.Write("  %s (*%s)(%s);\n" % (func.return_type, func.name, arg))
+      file.Write("};\n\n")
 
-      original_arg = func.MakeTypedOriginalArgString("")
-      context_arg = "PP_Resource context"
-      if len(original_arg):
-        arg = context_arg + ", " + original_arg
-      else:
-        arg = context_arg
-      file.Write("  %s (*%s)(%s);\n" % (func.return_type, func.name, arg))
-    file.Write("};\n\n")
 
     file.Close()
 
   def WritePepperGLES2Implementation(self, filename):
     """Writes the Pepper OpenGLES interface implementation."""
 
     file = CWriter(filename)
     file.Write(_LICENSE)
     file.Write(_DO_NOT_EDIT_WARNING)
 
     file.Write("#include \"ppapi/shared_impl/ppb_opengles2_shared.h\"\n\n")
     file.Write("#include \"base/logging.h\"\n")
     file.Write("#include \"gpu/command_buffer/client/gles2_implementation.h\"\n")
     file.Write("#include \"ppapi/shared_impl/ppb_graphics_3d_shared.h\"\n")
     file.Write("#include \"ppapi/thunk/enter.h\"\n\n")
 
     file.Write("namespace ppapi {\n\n")
     file.Write("namespace {\n\n")
 
     file.Write("gpu::gles2::GLES2Implementation*"
                " GetGLES(PP_Resource context) {\n")
     file.Write("  thunk::EnterResource<thunk::PPB_Graphics3D_API>"
                " enter_g3d(context, false);\n")
     file.Write("  DCHECK(enter_g3d.succeeded());\n")
     file.Write("  return static_cast<PPB_Graphics3D_Shared*>"
                "(enter_g3d.object())->gles2_impl();\n")
     file.Write("}\n\n")
 
     for func in self.original_functions:
-      if not func.IsCoreGLFunction():
+      if not func.InAnyPepperExtension():
         continue
 
       original_arg = func.MakeTypedOriginalArgString("")
       context_arg = "PP_Resource context_id"
       if len(original_arg):
         arg = context_arg + ", " + original_arg
       else:
         arg = context_arg
       file.Write("%s %s(%s) {\n" % (func.return_type, func.name, arg))
 
       return_str = "" if func.return_type == "void" else "return "
       file.Write("  %sGetGLES(context_id)->%s(%s);\n" %
                  (return_str, func.original_name,
                   func.MakeOriginalArgString("")))
       file.Write("}\n\n")
 
-    file.Write("\nconst struct PPB_OpenGLES2 ppb_opengles2 = {\n")
-    file.Write("  &")
-    file.Write(",\n  &".join(
-      f.name for f in self.original_functions if f.IsCoreGLFunction()))
-    file.Write("\n")
-    file.Write("};\n\n")
-
     file.Write("}  // namespace\n")
 
-    file.Write("""
-const PPB_OpenGLES2* PPB_OpenGLES2_Shared::GetInterface() {
-  return &ppb_opengles2;
-}
+    for interface in self.pepper_interfaces:
+      file.Write("const %s* PPB_OpenGLES2_Shared::Get%sInterface() {\n" %
+                 (interface.GetStructName(), interface.GetName()))
+      file.Write("  static const struct %s "
+                 "ppb_opengles2 = {\n" % interface.GetStructName())
+      file.Write("    &")
+      file.Write(",\n    &".join(
+        f.name 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()
 
   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("#include <GLES2/gl2.h>\n")
     file.Write("#include \"ppapi/lib/gl/gles2/gl2ext_ppapi.h\"\n\n")
 
     for func in self.original_functions:
-      if not func.IsCoreGLFunction():
+      if not func.InAnyPepperExtension():
         continue
 
+      interface = self.interface_info[func.GetInfo('pepper_interface') or '']
+
       file.Write("%s GL_APIENTRY gl%s(%s) {\n" %
                  (func.return_type, func.name,
                   func.MakeTypedOriginalArgString("")))
       return_str = "" if func.return_type == "void" else "return "
-      interface_str = "glGetInterfacePPAPI()"
+      interface_str = "glGet%sInterfacePPAPI()" % interface.GetName()
       original_arg = func.MakeOriginalArgString("")
       context_arg = "glGetCurrentContextPPAPI()"
       if len(original_arg):
         arg = context_arg + ", " + original_arg
       else:
         arg = context_arg
-      file.Write("  %s%s->%s(%s);\n" %
-                 (return_str, interface_str, func.name, arg))
+      if interface.GetName():
+        file.Write("  const struct %s* ext = %s;\n" %
+                   (interface.GetStructName(), interface_str))
+        file.Write("  if (ext)\n")
+        file.Write("    %sext->%s(%s);\n" %
+                   (return_str, func.name, arg))
+        if return_str:
+          file.Write("  %s0;\n" % return_str)
+      else:
+        file.Write("  %s%s->%s(%s);\n" %
+                   (return_str, interface_str, func.name, arg))
       file.Write("}\n\n")
+    file.Close()
 
   def WritePepperGLES2NaClProxy(self, filename):
     """Writes the Pepper OpenGLES interface implementation for NaCl."""
     file = CWriter(filename)
     file.Write(_LICENSE)
     file.Write(_DO_NOT_EDIT_WARNING)
 
     file.Write("#include \"native_client/src/shared/ppapi_proxy"
         "/plugin_ppb_graphics_3d.h\"\n\n")
 
     file.Write("#include \"gpu/command_buffer/client/gles2_implementation.h\"")
-    file.Write("\n#include \"native_client/src/third_party"
-        "/ppapi/c/dev/ppb_opengles_dev.h\"\n\n")
+    file.Write("\n#include \"ppapi/c/ppb_opengles2.h\"\n\n")
 
     file.Write("using ppapi_proxy::PluginGraphics3D;\n")
     file.Write("using ppapi_proxy::PluginResource;\n\n")
     file.Write("namespace {\n\n")
 
     for func in self.original_functions:
-      if not func.IsCoreGLFunction():
+      if not func.InAnyPepperExtension():
         continue
       args = func.MakeTypedOriginalArgString("")
       if len(args) != 0:
         args = ", " + args
       file.Write("%s %s(PP_Resource context%s) {\n" %
                  (func.return_type, func.name, args))
       return_string = "return "
       if func.return_type == "void":
         return_string = ""
       file.Write("  %sPluginGraphics3D::implFromResource(context)->"
                  "%s(%s);\n" %
                  (return_string,
                   func.original_name,
                   func.MakeOriginalArgString("")))
       file.Write("}\n")
 
     file.Write("\n} // namespace\n\n")
 
-    file.Write("const PPB_OpenGLES2* "
-               "PluginGraphics3D::GetOpenGLESInterface() {\n")
+    for interface in self.pepper_interfaces:
+      file.Write("const %s* "
+                 "PluginGraphics3D::GetOpenGLES%sInterface() {\n" %
+                 (interface.GetStructName(), interface.GetName()))
 
-    file.Write("  const static struct PPB_OpenGLES2 ppb_opengles = {\n")
-    file.Write("    &")
-    file.Write(",\n    &".join(
-      f.name for f in self.original_functions if f.IsCoreGLFunction()))
-    file.Write("\n")
-    file.Write("  };\n")
-    file.Write("  return &ppb_opengles;\n")
-    file.Write("}\n")
+      file.Write("  const static struct %s ppb_opengles = {\n" %
+                 interface.GetStructName())
+      file.Write("    &")
+      file.Write(",\n    &".join(
+        f.name for f in self.original_functions
+          if f.InPepperInterface(interface)))
+      file.Write("\n")
+      file.Write("  };\n")
+      file.Write("  return &ppb_opengles;\n")
+      file.Write("}\n")
     file.Close()
 
 
 def main(argv):
   """This is the main function."""
   parser = OptionParser()
   parser.add_option(
       "-g", "--generate-implementation-templates", action="store_true",
       help="generates files that are generally hand edited..")
   parser.add_option(
@@ skipping 19 matching lines @@
   gen = GLGenerator(options.verbose)
   gen.ParseGLH("common/GLES2/gl2.h")
 
   # Support generating files under gen/
   if options.output_dir != None:
     os.chdir(options.output_dir)
 
   if options.alternate_mode == "ppapi":
     # To trigger this action, do "make ppapi_gles_bindings"
     os.chdir("ppapi");
-    gen.WritePepperGLES2Interface("c/ppb_opengles2.h")
+    gen.WritePepperGLES2Interface("c/ppb_opengles2.h", False)
+    gen.WritePepperGLES2Interface("c/dev/ppb_opengles2ext_dev.h", True)
     gen.WriteGLES2ToPPAPIBridge("lib/gl/gles2/gles2.c")
 
   elif options.alternate_mode == "chrome_ppapi":
     # To trigger this action, do "make ppapi_gles_implementation"
     gen.WritePepperGLES2Implementation(
         "ppapi/shared_impl/ppb_opengles2_shared.cc")
 
   elif options.alternate_mode == "nacl_ppapi":
+    os.chdir("ppapi")
     gen.WritePepperGLES2NaClProxy(
         "native_client/src/shared/ppapi_proxy/plugin_opengles.cc")
 
   else:
     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.WriteGLES2ImplementationHeader("client/gles2_implementation_autogen.h")
     gen.WriteGLES2ImplementationUnitTests(
         "client/gles2_implementation_unittest_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.WriteServiceUnitTests("service/gles2_cmd_decoder_unittest_%d_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")
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))