Move html events generation to domimpl.

lib/dom/scripts/dartgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2012, 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 75 matching lines @@
 
     References through all interfaces will be renamed as well.
 
     Args:
       database: the database to apply the renames to.
       conversion_table: maps old names to new names.
     """
 
     if conversion_table is None:
       conversion_table = {}
-     
+
     # Rename interfaces:
     for old_name, new_name in conversion_table.items():
       if database.HasInterface(old_name):
         _logger.info('renaming interface %s to %s' % (old_name, new_name))
         interface = database.GetInterface(old_name)
         database.DeleteInterface(old_name)
         if not database.HasInterface(new_name):
           interface.id = new_name
           database.AddInterface(interface)
         else:
           new_interface = database.GetInterface(new_name)
           MergeNodes(new_interface, interface)
-        
+
         if rename_javascript_binding_names:
           interface.javascript_binding_name = new_name
           interface.doc_js_name = new_name
           for member in (interface.operations + interface.constants
               + interface.attributes):
             member.doc_js_interface_name = new_name
 
- 
+
     # Fix references:
     for interface in database.GetInterfaces():
       for idl_type in interface.all(idlnode.IDLType):
         type_name = self._StripModules(idl_type.id)
         if type_name in conversion_table:
           idl_type.id = conversion_table[type_name]
 
   def FilterMembersWithUnidentifiedTypes(self, database):
     """Removes unidentified types.
 
@@ skipping 73 matching lines @@
         interface.operations = filter(HasAnnotations, interface.operations)
         interface.parents = filter(HasAnnotations, interface.parents)
       else:
         database.DeleteInterface(interface.id)
 
     self.FilterMembersWithUnidentifiedTypes(database)
 
 
   def Generate(self, database, output_dir,
                module_source_preference=[], source_filter=None,
-               super_database=None, common_prefix=None, super_map={},
-               html_map={}, lib_dir=None, systems=[]):
+               super_database=None, common_prefix=None,
+               webkit_renames={},
+               html_renames={},
+               lib_dir=None,
+               systems=[]):
     """Generates Dart and JS files for the loaded interfaces.
 
     Args:
       database -- database containing interfaces to generate code for.
       output_dir -- directory to write generated files to.
       module_source_preference -- priority order list of source annotations to
         use when choosing a module name, if none specified uses the module name
         from the database.
       source_filter -- if specified, only outputs interfaces that have one of
         these source annotation and rewrites the names of superclasses not
         marked with this source to use the common prefix.
       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._FixEventTargets()
     self._ComputeInheritanceClosure()
 
     self._systems = []
 
     # TODO(jmesserly): only create these if needed
     if ('htmlfrog' in systems) or ('htmldartium' in systems):
       html_interface_system = HtmlInterfacesSystem(
           TemplateLoader(self._template_dir, ['html/interface', 'html', '']),
           self._database, self._emitters, self._output_dir, self)
       self._systems.append(html_interface_system)
     else:
       interface_system = InterfacesSystem(
           TemplateLoader(self._template_dir, ['dom/interface', 'dom', '']),
           self._database, self._emitters, self._output_dir)
       self._systems.append(interface_system)
 
     if 'native' in systems:
       native_system = NativeImplementationSystem(
           TemplateLoader(self._template_dir, ['dom/native', 'dom', '']),
-          self._database, self._emitters, self._auxiliary_dir,
+          self._database, html_renames, self._emitters, self._auxiliary_dir,
           self._output_dir)
 
       self._systems.append(native_system)
 
     if 'dummy' in systems:
       dummy_system = DummyImplementationSystem(
           TemplateLoader(self._template_dir, ['dom/dummy', 'dom', '']),
           self._database, self._emitters, self._output_dir)
 
       # Makes interface files available for listing in the library for the
@@ skipping 36 matching lines @@
       if not MatchSourceFilter(source_filter, interface):
         # Skip this interface since it's not present in the required source
         _logger.info('Omitting interface - %s' % interface.id)
         continue
       interfaces.append(interface)
 
     # TODO(sra): Use this list of exception names to generate information to
     # tell Frog which exceptions can be passed from JS to Dart code.
     exceptions = self._CollectExceptions(interfaces)
 
+    super_map = dict((v,k) for k, v in webkit_renames.iteritems())
+
     # Render all interfaces into Dart and save them in files.
     for interface in self._PreOrderInterfaces(interfaces):
 
       super_interface = None
       super_name = interface.id
 
       if super_name in super_map:
         super_name = super_map[super_name]
 
       if (super_database is not None and
@@ skipping 313 matching lines @@
     pass
 
   def AddOperation(self, info):
     pass
 
   def AddStaticOperation(self, info):
     pass
 
   def AddEventAttributes(self, event_attrs):
     pass