Make per-interface generators an implementation detail of a system.

lib/dom/scripts/systemfrog.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 provides shared functionality for the systems to generate
 frog binding from the IDL database."""
 
 import os
 from generator import *
@@ skipping 11 matching lines @@
     'HTMLIFrameElement.get:contentDocument',
 ])
 
 class FrogSystem(System):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(FrogSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._impl_file_paths = []
 
-  def InterfaceGenerator(self,
-                         interface,
-                         common_prefix,
-                         super_interface_name,
-                         source_filter):
+  def ProcessInterface(self, interface):
     """."""
     if IsPureInterface(interface.id):
       return
     template_file = 'impl_%s.darttemplate' % interface.id
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('frog_impl.darttemplate')
 
     dart_code = self._ImplFileEmitter(interface.id)
-    return FrogInterfaceGenerator(self, interface, template,
-                                  super_interface_name, dart_code)
+    FrogInterfaceGenerator(self, interface, template, dart_code).Generate()
 
   def GenerateLibraries(self):
     self._GenerateLibFile(
         'frog_dom.darttemplate',
         os.path.join(self._output_dir, 'dom_frog.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
          self._impl_file_paths))
 
   def Finish(self):
     pass
 
   def _ImplFileEmitter(self, name):
     """Returns the file emitter of the Frog implementation file."""
     path = os.path.join(self._output_dir, 'src', 'frog', '%s.dart' % name)
     self._impl_file_paths.append(path)
     return self._emitters.FileEmitter(path)
 
 # ------------------------------------------------------------------------------
 
 class FrogInterfaceGenerator(BaseGenerator):
   """Generates a Frog class for a DOM IDL interface."""
 
-  def __init__(self, system, interface, template, super_interface, dart_code):
+  def __init__(self, system, interface, template, dart_code):
     """Generates Dart code for the given interface.
 
     Args:
 
       interface: an IDLInterface instance. It is assumed that all types have
           been converted to Dart types (e.g. int, String), unless they are in
           the same package as the interface.
       template: A string template.
-      super_interface: A string or None, the name of the common interface that
-          this interface implements, if any.
       dart_code: an Emitter for the file containing the Dart implementation
           class.
     """
-    super(FrogInterfaceGenerator, self).__init__(system._database)
+    super(FrogInterfaceGenerator, self).__init__(system._database, interface)
     self._system = system
     self._interface = interface
     self._template = template
-    self._super_interface = super_interface
     self._dart_code = dart_code
     self._current_secondary_parent = None
 
 
   def StartInterface(self):
     interface = self._interface
     interface_name = interface.id
     self._class_name = self._ImplClassName(interface_name)
 
     base = None
@@ skipping 295 matching lines @@
     if native_body:
       native_string = " '''" + native_body + "'''"
 
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS) native$NATIVESTRING;\n',
         TYPE=self._NarrowOutputType(info.type_name),
         NAME=info.name,
         PARAMS=params,
         NATIVESTRING=native_string)