Pepper: Autogenerate thunk for PPB_TrueTypeFont.

ppapi/generators/idl_thunk.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.
 
 """ Generator for C++ style thunks """
 
 import glob
 import os
 import re
@@ skipping 83 matching lines @@
   """Adds an API header for the given file to the ThunkBodyMetadata."""
   # The API header matches the file name, not the interface name.
   api_basename = _GetBaseFileName(filenode)
   if api_basename.endswith('_dev'):
     api_basename = api_basename[:-len('_dev')]
   if api_basename.endswith('_trusted'):
     api_basename = api_basename[:-len('_trusted')]
   meta.AddApi(api_basename + '_api')
 
 
-def _MakeEnterLine(filenode, interface, arg, handle_errors, callback, meta):
+def _MakeEnterLine(filenode, interface, member, arg, handle_errors, callback,
+                   meta):
   """Returns an EnterInstance/EnterResource string for a function."""
   api_name = interface.GetName()
   if api_name.endswith('Trusted'):
     api_name = api_name[:-len('Trusted')]
   if api_name.endswith('_Dev'):
     api_name = api_name[:-len('_Dev')]
   api_name += '_API'
+  if member.GetProperty('api'):  # Override API name.
+    manually_provided_api = True
+    # TODO(teravest): Automatically guess the API header file.
+    api_name = member.GetProperty('api')
+  else:
+    manually_provided_api = False
 
   if arg[0] == 'PP_Instance':
     if callback is None:
       arg_string = arg[1]
     else:
       arg_string = '%s, %s' % (arg[1], callback)
-    if interface.GetProperty('singleton_resource'):
-      _AddApiHeader(filenode, meta)
+    if member.GetProperty('singleton'):
+      if not manually_provided_api:
+        _AddApiHeader(filenode, meta)
       return 'EnterInstanceAPI<%s> enter(%s);' % (api_name, arg_string)
     else:
       return 'EnterInstance enter(%s);' % arg_string
   elif arg[0] == 'PP_Resource':
     enter_type = 'EnterResource<%s>' % api_name
-    _AddApiHeader(filenode, meta)
+    if not manually_provided_api:
+      _AddApiHeader(filenode, meta)
     if callback is None:
       return '%s enter(%s, %s);' % (enter_type, arg[1],
                                     str(handle_errors).lower())
     else:
       return '%s enter(%s, %s, %s);' % (enter_type, arg[1],
                                         callback,
                                         str(handle_errors).lower())
   else:
     raise TGenError("Unknown type for _MakeEnterLine: %s" % arg[0])
 
@@ skipping 102 matching lines @@
   if include_version:
     version = node.GetVersion(release).replace('.', '_')
     function_name += version
 
   invocation = 'enter.%s()->%s(%s)' % (function_container,
                                        function_name,
                                        call_arglist)
 
   handle_errors = not (member.GetProperty('report_errors') == 'False')
   if is_callback_func:
-    body = '%s\n' % _MakeEnterLine(filenode, node, args[0], handle_errors,
-                                   args[len(args) - 1][1], meta)
+    body = '%s\n' % _MakeEnterLine(filenode, node, member, args[0],
+                                   handle_errors, args[len(args) - 1][1], meta)
     body += 'if (enter.failed())\n'
     value = member.GetProperty('on_failure')
     if value is None:
       value = 'enter.retval()'
     body += '  return %s;\n' % value
     body += 'return enter.SetResult(%s);' % invocation
   elif rtype == 'void':
     # On failure, zero out all output parameters.
     out_params = []
     callnode = member.GetOneOf('Callspec')
     if callnode:
       cgen = CGen()
       for param in callnode.GetListOf('Param'):
         mode = cgen.GetParamMode(param)
         if mode == 'out':
           # We use the 'store' mode when getting the parameter type, since we
           # need to call sizeof() for memset().
           ptype, pname, _, _ = cgen.GetComponents(param, release, 'store')
           out_params.append((pname, ptype))
 
-    body = '%s\n' % _MakeEnterLine(filenode, node, args[0], handle_errors,
-                                   None, meta)
+    body = '%s\n' % _MakeEnterLine(filenode, node, member, args[0],
+                                   handle_errors, None, meta)
     if not out_params:
       body += 'if (enter.succeeded())\n'
       body += '  %s;' % invocation
     else:
       body += 'if (enter.succeeded()) {\n'
       body += '  %s;\n' % invocation
       body += '  return;\n'
       body += '}'
       for param in out_params:
         body += '\nmemset(%s, 0, sizeof(%s));' % param
       meta.AddBuiltinInclude('string.h')
 
   else:
     value = member.GetProperty('on_failure')
     if value is None:
       value = _GetDefaultFailureValue(rtype)
     if value is None:
       raise TGenError('No default value for rtype %s' % rtype)
 
-    body = '%s\n' % _MakeEnterLine(filenode, node, args[0], handle_errors,
-                                   None, meta)
+    body = '%s\n' % _MakeEnterLine(filenode, node, member, args[0],
+                                   handle_errors, None, meta)
     body += 'if (enter.failed())\n'
     body += '  return %s;\n' % value
     body += 'return %s;' % invocation
   return body
 
 
 def DefineMember(filenode, node, member, release, include_version, meta):
   """Returns a definition for a member function of an interface.
 
   Args:
     filenode - IDLNode for the file
     node - IDLNode for the interface
     member - IDLNode for the member function
     release - release to generate
     include_version - include the version in emitted function name.
     meta - ThunkMetadata for header hints
   Returns:
     A string with the member definition.
   """
   cgen = CGen()
   rtype, name, arrays, args = cgen.GetComponents(member, release, 'return')
 
-  if _IsTypeCheck(node, member):
-    body = '%s\n' % _MakeEnterLine(filenode, node, args[0], False, None, meta)
+  if _IsTypeCheck(node, member) or member.GetProperty('is_function'):
+    body = '%s\n' % _MakeEnterLine(filenode, node, member, args[0], False, None,
+                                   meta)
     body += 'return PP_FromBool(enter.succeeded());'
   elif member.GetName() == 'Create':
     body = _MakeCreateMemberBody(node, member, args)
   else:
     body = _MakeNormalMemberBody(filenode, release, node, member, rtype, args,
                                  include_version, meta)
 
   signature = cgen.GetSignature(member, release, 'return', func_as_ptr=False,
                                 include_version=include_version)
   return '%s\n%s\n}' % (cgen.Indent('%s {' % signature, tabs=0),
@@ skipping 40 matching lines @@
       if os.path.isfile(savename):
         print "Removing stale %s for this range." % filenode.GetName()
         os.remove(os.path.realpath(savename))
       return False
     do_generate = filenode.GetProperty('generate_thunk')
     if not do_generate:
       return False
 
     thunk_out = IDLOutFile(savename)
     body, meta = self.GenerateBody(thunk_out, filenode, releases, options)
+    # TODO(teravest): How do we handle repeated values?
+    if filenode.GetProperty('thunk_include'):
+      meta.AddInclude(filenode.GetProperty('thunk_include'))
     self.WriteHead(thunk_out, filenode, releases, options, meta)
     thunk_out.Write('\n\n'.join(body))
     self.WriteTail(thunk_out, filenode, releases, options)
     return thunk_out.Close()
 
   def WriteHead(self, out, filenode, releases, options, meta):
     __pychecker__ = 'unusednames=options'
     cgen = CGen()
 
     cright_node = filenode.GetChildren()[0]
@@ skipping 137 matching lines @@
     print "Golden file for M13-M14 failed."
     failed = 1
   else:
     print "Golden file for M13-M14 passed."
 
   return failed
 
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv[1:]))