Generate callbacks as typedefs.

client/dom/scripts/dartgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 340 matching lines @@
       super_database -- database containing super interfaces that the generated
         interfaces should extend.
       common_prefix -- prefix for the common library, if any.
       lib_file_path -- filename for generated .lib file, None if not required.
       lib_template -- template file in this directory for generated lib file.
     """
 
     self._emitters = multiemitter.MultiEmitter()
     self._database = database
     self._output_dir = output_dir
+    self._dart_callback_file_paths = []
 
     self._StartGenerateInterfaceLibrary()
     self._StartGenerateJavaScriptMonkeyImpl(database, output_dir)
     self._StartGenerateWrappingImpl(output_dir)
     self._StartGenerateFrogImpl(output_dir)
 
     # Render all interfaces into Dart and save them in files.
     dart_file_paths = []
     processed_interfaces = []
     for interface in database.GetInterfaces():
@@ skipping 13 matching lines @@
           super_database.HasInterface(super_name)):
         super_interface = super_name
 
       interface_name = interface.id
       auxiliary_file = self._auxiliary_files.get(interface_name)
       if auxiliary_file is not None:
         _logger.info('Skipping %s because %s exists' % (
             interface_name, auxiliary_file))
         continue
 
-      self._ProcessInterface(interface, super_interface,
-                             source_filter, common_prefix)
+
+      info = self._RecognizeCallback(interface)
+      if info:
+        self._ProcessCallback(interface, info)
+      else:
+        if 'Callback' in interface.ext_attrs:
+          _logger.info('Malformed callback: %s' % interface.id)
+        self._ProcessInterface(interface, super_interface,
+                               source_filter, common_prefix)
       processed_interfaces.append(interface)
 
     self._GenerateBrowserAnalysis(processed_interfaces, output_dir)
 
 
     # Libraries
     if lib_dir:
       # New version: Monkey-patching interface library.
       self.GenerateLibFile('template_monkey_dom.darttemplate',
                            os.path.join(lib_dir, 'monkey_dom.dart'),
-                           self._dart_interface_file_paths)
+                           self._dart_interface_file_paths +
+                           self._dart_callback_file_paths)
 
       # New version: Wrapping implementation combined interface and
       # implementation library.
       self.GenerateLibFile('template_wrapping_dom.darttemplate',
                            os.path.join(lib_dir, 'wrapping_dom.dart'),
                            (self._dart_interface_file_paths +
+                            self._dart_callback_file_paths +
                             # FIXME: Move the implementation to a separate
                             # library.
                             self._dart_wrapping_file_paths))
 
       # New version: Frog
       self.GenerateLibFile('template_frog_dom.darttemplate',
                            os.path.join(lib_dir, 'frog_dom.dart'),
-                           self._dart_frog_file_paths)
+                           self._dart_frog_file_paths +
+                           self._dart_callback_file_paths)
 
 
     # JavaScript externs files
     self._GenerateJavaScriptExternsMonkey(database, output_dir)
     self._GenerateJavaScriptExternsWrapping(database, output_dir)
 
 
+  def _RecognizeCallback(self, interface):
+    """Returns the info for the callback method if the interface smells like a
+    callback.
+    """
+    if 'Callback' not in interface.ext_attrs: return None
+    handlers = [op for op in interface.operations if op.id == 'handleEvent']
+    if not handlers: return None
+    if not (handlers == interface.operations): return None
+    return self._AnalyzeOperation(interface, handlers)
+
+  def _ProcessCallback(self, interface, info):
+    """Generates a typedef for the callback interface."""
+    interface_name = interface.id
+    file_path = self.FilePathForDartInterface(interface_name)
+    self._dart_callback_file_paths.append(file_path)
+    code = self._emitters.FileEmitter(file_path)
+
+    template_file = 'template_callback.darttemplate'
+    code.Emit(''.join(open(template_file).readlines()))
+    code.Emit('typedef $TYPE $NAME($ARGS);\n',
+              NAME=interface.id,
+              TYPE=info.type_name,
+              ARGS=info.arg_implementation_declaration)
+
+
+
   def _ProcessInterface(self, interface, super_interface_name,
                         source_filter,
                         common_prefix):
     """."""
     _logger.info('Generating %s' % interface.id)
 
     dart_interface_generator = self._MakeDartInterfaceGenerator(
         interface,
         common_prefix,
         super_interface_name,
@@ skipping 361 matching lines @@
     """."""
     interface_name = interface.id
     dart_frog_file_path = self.FilePathForFrogImpl(interface_name)
 
     self._dart_frog_file_paths.append(dart_frog_file_path)
 
     dart_code = self._emitters.FileEmitter(dart_frog_file_path)
     dart_code.Emit(
         ''.join(open('template_frog_impl.darttemplate').readlines()))
     return FrogInterfaceGenerator(interface, super_interface_name,
-                                    dart_code)
+                                  dart_code)
 
 
   def _StartGenerateJavaScriptMonkeyImpl(self, database, output_dir):
     """Generate a JavaScript implementation that is coherent with
     generated Dart APIs.
     """
     self._ComputeInheritanceClosure(database)
     js_file_name = os.path.join(output_dir, 'monkey_dom.js')
     code = self._emitters.FileEmitter(js_file_name)
 
@@ skipping 1267 matching lines @@
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($ARGS) native;\n',
         TYPE=info.type_name,
         NAME=info.name,
         ARGS=info.arg_implementation_declaration)