Make HtmlFrogSystem and NativeImplementationSystem the backends for HtmlInterfacesSystem and remove…

lib/dom/scripts/systemhtml.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 system to generate
 Dart:html APIs from the IDL database."""
 
 from systemfrog import *
 from systeminterface import *
@@ skipping 749 matching lines @@
 
 class HtmlSystem(System):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(HtmlSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._shared = HtmlSystemShared(database)
 
 class HtmlInterfacesSystem(HtmlSystem):
 
-  def __init__(self, templates, database, emitters, output_dir):
+  def __init__(self, templates, database, emitters, output_dir, backend):
     super(HtmlInterfacesSystem, self).__init__(
         templates, database, emitters, output_dir)
+    self._backend = backend
     self._dart_interface_file_paths = []
     self._factory_provider_emitters = {}
 
   def ProcessInterface(self, interface):
     """."""
+
+    self._backend.ProcessInterface(interface)
+
     if interface.id in _merged_html_interfaces:
       return
 
     html_interface_name = self._shared._HTMLInterfaceName(interface.id)
     dart_interface_file_path = self._FilePathForDartInterface(
         html_interface_name)
 
     self._dart_interface_file_paths.append(dart_interface_file_path)
 
     dart_interface_code = self._emitters.FileEmitter(dart_interface_file_path)
 
     template_file = 'interface_%s.darttemplate' % html_interface_name
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('interface.darttemplate')
 
     generator = HtmlDartInterfaceGenerator(
         self, interface, dart_interface_code,
         template, self._shared)
     generator.Generate()
 
   def ProcessCallback(self, interface, info):
     """Generates a typedef for the callback interface."""
     interface_name = interface.id
     file_path = self._FilePathForDartInterface(interface_name)
     self._ProcessCallback(interface, info, file_path)
 
   def GenerateLibraries(self):
-    pass
-
+    self._backend.GenerateLibraries(self._dart_interface_file_paths)
 
   def _FilePathForDartInterface(self, interface_name):
     """Returns the file path of the Dart interface definition."""
     # TODO(jmesserly): is this the right path
     return os.path.join(self._output_dir, 'html', 'interface',
                         '%s.dart' % interface_name)
 
 # ------------------------------------------------------------------------------
 
 # TODO(jmesserly): inheritance is probably not the right way to factor this long
@@ skipping 541 matching lines @@
     template_file = 'impl_%s.darttemplate' % html_interface_name
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('frog_impl.darttemplate')
 
     dart_code = self._ImplFileEmitter(html_interface_name)
     generator = HtmlFrogClassGenerator(self, interface, template,
                                        dart_code, self._shared)
     generator.Generate()
 
-  def GenerateLibraries(self):
+  def GenerateLibraries(self, interface_files):
     self._GenerateLibFile(
         'html_frog.darttemplate',
         os.path.join(self._output_dir, 'html_frog.dart'),
-        (self._interface_system._dart_interface_file_paths +
-         self._interface_system._dart_callback_file_paths +
-         self._dart_frog_file_paths))
+        interface_files + self._dart_frog_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, 'html', 'frog', '%s.dart' % name)
     self._dart_frog_file_paths.append(path)
     return self._emitters.FileEmitter(path)
 
   def _EmitterForFactoryProviderBody(self, name):
     if name not in self._factory_provider_emitters:
       template = self._templates.Load('factoryprovider_%s.darttemplate' % name)
       file_emitter = self._ImplFileEmitter(name)
       self._factory_provider_emitters[name] = file_emitter.Emit(template)
     return self._factory_provider_emitters[name]
 
 # -----------------------------------------------------------------------------
 
-class HtmlDartiumSystem(HtmlSystem):
-
-  def __init__(self, templates, database, emitters, auxiliary_dir,
-               dom_implementation_classes, output_dir):
-    """Prepared for generating wrapping implementation.
-
-    - Creates emitter for Dart code.
-    """
-    super(HtmlDartiumSystem, self).__init__(
-        templates, database, emitters, output_dir)
-    self._auxiliary_dir = auxiliary_dir
-    self._dom_implementation_classes = dom_implementation_classes
-
-  def ProcessInterface(self, interface):
-    # Implementation classes are generated by NativeImplementationSystem.
-    # FIXME: merge HtmlDartiumSystem into NativeImplementationSystem.
-    pass
-
-  def ProcessCallback(self, interface, info):
-    pass
-
-  def GenerateLibraries(self):
-    # Library generated for implementation.
-    auxiliary_dir = os.path.relpath(self._auxiliary_dir, self._output_dir)
-
-    self._GenerateLibFile(
-        'html_dartium.darttemplate',
-        os.path.join(self._output_dir, 'html_dartium.dart'),
-        (self._interface_system._dart_interface_file_paths +
-         self._interface_system._dart_callback_file_paths +
-         self._dom_implementation_classes),
-        AUXILIARY_DIR=MassagePath(auxiliary_dir))
-
-  def Finish(self):
-    pass
-
-
 def _ComputeInheritanceClosure(database):
   def Collect(interface, seen, collected):
     name = interface.id
     if '<' in name:
       # TODO(sra): Handle parameterized types.
       return
     if not name in seen:
       seen.add(name)
       collected.append(name)
       for parent in interface.parents:
         # TODO(sra): Handle parameterized types.
         if not '<' in parent.type.id:
           if database.HasInterface(parent.type.id):
             Collect(database.GetInterface(parent.type.id),
                     seen, collected)
 
   inheritance_closure = {}
   for interface in database.GetInterfaces():
     seen = set()
     collected = []
     Collect(interface, seen, collected)
     inheritance_closure[interface.id] = collected
   return inheritance_closure