Extract common FactoryProviders generation logic.

lib/dom/scripts/systemnative.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
 native binding from the IDL database."""
 
 import emitter
 import os
 import systembase
 from generator import *
-from systemhtml import DomToHtmlEvent, DomToHtmlEvents, HtmlSystemShared
-from systemhtml import HtmlElementConstructorInfos
-from systemhtml import EmitHtmlElementFactoryConstructors
+from systemhtml import HtmlSystemShared
+
 
 class NativeImplementationSystem(systembase.System):
 
   def __init__(self, templates, database, emitters, output_dir, auxiliary_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
     self._auxiliary_dir = auxiliary_dir
-    self._dom_impl_files = []
     self._cpp_header_files = []
     self._cpp_impl_files = []
     self._html_system = HtmlSystemShared(database)
-    self._factory_provider_emitters = {}
 
   def ImplementationGenerator(self, interface):
     return NativeImplementationGenerator(self, interface)
 
   def ProcessCallback(self, interface, info):
     self._interface = interface
 
     if IsPureInterface(self._interface.id):
       return None
 
@@ skipping 61 matching lines @@
         INCLUDES=_GenerateCPPIncludes(cpp_impl_includes),
         INTERFACE=self._interface.id,
         HANDLERS=cpp_impl_handlers_emitter.Fragments())
 
   def GenerateLibraries(self, interface_files):
     # Generate dart:html library.
     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'),
-        interface_files + self._dom_impl_files,
+        interface_files,
         AUXILIARY_DIR=systembase.MassagePath(auxiliary_dir))
 
     # Generate DartDerivedSourcesXX.cpp.
     partitions = 20 # FIXME: this should be configurable.
     sources_count = len(self._cpp_impl_files)
     for i in range(0, partitions):
       derived_sources_path = os.path.join(self._output_dir,
           'DartDerivedSources%02i.cpp' % (i + 1))
 
       includes_emitter = emitter.Emitter()
@@ skipping 21 matching lines @@
 
     cpp_resolver_emitter = self._emitters.FileEmitter(cpp_resolver_path)
     cpp_resolver_emitter.Emit(
         self._templates.Load('cpp_resolver.template'),
         INCLUDES=includes_emitter.Fragments(),
         RESOLVER_BODY=resolver_body_emitter.Fragments())
 
   def Finish(self):
     pass
 
-  def _FilePathForDartFactoryProviderImplementation(self, interface_name):
-    return os.path.join(self._output_dir, 'dart',
-                        '%sFactoryProviderImplementation.dart' % interface_name)
-
   def _FilePathForCppHeader(self, interface_name):
     return os.path.join(self._output_dir, 'cpp', 'Dart%s.h' % interface_name)
 
   def _FilePathForCppImplementation(self, interface_name):
     return os.path.join(self._output_dir, 'cpp', 'Dart%s.cpp' % interface_name)
 
-  def _EmitterForFactoryProviderBody(self, name):
-    if name not in self._factory_provider_emitters:
-      file_name = self._FilePathForDartFactoryProviderImplementation(name)
-      self._dom_impl_files.append(file_name)
-      template = self._templates.Load('factoryprovider_%s.darttemplate' % name)
-      file_emitter = self._emitters.FileEmitter(file_name)
-      self._factory_provider_emitters[name] = file_emitter.Emit(template)
-    return self._factory_provider_emitters[name]
-
 
 class NativeImplementationGenerator(systembase.BaseGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
   def __init__(self, system, interface):
     """Generates Dart and C++ code for the given interface.
 
     Args:
       system: The NativeImplementationSystem.
       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.
     """
     super(NativeImplementationGenerator, self).__init__(
         system._database, interface)
     self._system = system
     self._current_secondary_parent = None
     self._html_system = self._system._html_system
-    self._html_renames = self._html_system._html_renames
+    self._html_interface_name = self._html_system._html_renames.get(
+        self._interface.id, self._interface.id)
 
   def HasImplementation(self):
     return not IsPureInterface(self._interface.id)
 
   def ImplementationClassName(self):
     return self._ImplClassName(self._interface.id)
 
   def FilePathForDartImplementation(self):
     return os.path.join(self._system._output_dir, 'dart',
                         '%sImplementation.dart' % self._interface.id)
 
+  def FilePathForDartFactoryProviderImplementation(self):
+    file_name = '%sFactoryProviderImplementation.dart' % self._interface.id
+    return os.path.join(self._system._output_dir, 'dart', file_name)
+
+  def FilePathForDartElementsFactoryProviderImplementation(self):
+    return os.path.join(self._system._output_dir, 'dart',
+                        '_ElementsFactoryProviderImplementation.dart')
+
   def SetImplementationEmitter(self, implementation_emitter):
     self._dart_impl_emitter = implementation_emitter
 
   def AddMergedMembers(self, merged_interface):
     # We could not add merged functions to implementation class because
     # underlying c++ object doesn't implement them. Merged functions are
     # generated on merged interface implementation instead.
     pass
 
   def StartInterface(self):
@@ skipping 13 matching lines @@
     self._members_emitter = emitter.Emitter()
     self._cpp_declarations_emitter = emitter.Emitter()
     self._cpp_impl_includes = set()
     self._cpp_definitions_emitter = emitter.Emitter()
     self._cpp_resolver_emitter = emitter.Emitter()
 
     self._GenerateConstructors()
     return self._members_emitter
 
   def _GenerateConstructors(self):
-    html_interface_name = self._HTMLInterfaceName(self._interface.id)
-
     if not self._IsConstructable():
       return
 
     # TODO(antonm): currently we don't have information about number of arguments expected by
     # the constructor, so name only dispatch.
     self._cpp_resolver_emitter.Emit(
         '    if (name == "$(INTERFACE_NAME)_constructor_Callback")\n'
         '        return Dart$(INTERFACE_NAME)Internal::constructorCallback;\n',
         INTERFACE_NAME=self._interface.id)
 
 
     constructor_info = AnalyzeConstructor(self._interface)
-    if constructor_info:
-      self._EmitFactoryProvider(self._interface.id, constructor_info)
 
     ext_attrs = self._interface.ext_attrs
 
     if 'CustomConstructor' in ext_attrs:
       # We have a custom implementation for it.
       self._cpp_declarations_emitter.Emit(
           '\n'
           'void constructorCallback(Dart_NativeArguments);\n')
       return
 
@@ skipping 90 matching lines @@
     # FIXME: We're currently injecting List<..> and EventTarget as
     # supertypes in dart.idl. We should annotate/preserve as
     # attributes instead.  For now, this hack lets the self._interfaces
     # inherit, but not the classes.
     # List methods are injected in AddIndexer.
     if IsDartListType(supertype) or IsDartCollectionType(supertype):
       return root_class
 
     return self._ImplClassName(supertype)
 
-  def _HTMLInterfaceName(self, interface_name):
-    return self._html_renames.get(interface_name, interface_name)
-
   def _IsConstructable(self):
     # FIXME: support ConstructorTemplate.
     return set(['CustomConstructor', 'V8CustomConstructor', 'Constructor', 'NamedConstructor']) & set(self._interface.ext_attrs)
 
-  def _EmitFactoryProvider(self, interface_name, constructor_info):
-    dart_impl_path = self._system._FilePathForDartFactoryProviderImplementation(
-        interface_name)
-    self._system._dom_impl_files.append(dart_impl_path)
-
-    html_interface_name = self._HTMLInterfaceName(interface_name)
-    template_file = 'factoryprovider_%s.darttemplate' % html_interface_name
+  def EmitFactoryProvider(self, constructor_info, factory_provider, emitter):
+    template_file = 'factoryprovider_%s.darttemplate' % self._html_interface_name
     template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('factoryprovider.darttemplate')
 
-    native_implementation_function = '%s_constructor_Callback' % interface_name
-    emitter = self._system._emitters.FileEmitter(dart_impl_path)
+    native_binding = '%s_constructor_Callback' % self._interface.id
     emitter.Emit(
         template,
-        FACTORYPROVIDER='_%sFactoryProvider' % html_interface_name,
-        INTERFACE=html_interface_name,
+        FACTORYPROVIDER=factory_provider,
+        INTERFACE=self._html_interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
         ARGUMENTS=constructor_info.ParametersAsArgumentList(),
-        NATIVE_NAME=native_implementation_function)
+        NATIVE_NAME=native_binding)
 
   def FinishInterface(self):
-    html_interface_name = self._HTMLInterfaceName(self._interface.id)
     template = None
-    if html_interface_name == self._interface.id or not self._database.HasInterface(html_interface_name):
-      template_file = 'impl_%s.darttemplate' % html_interface_name
+    if self._html_interface_name == self._interface.id or not self._database.HasInterface(self._html_interface_name):
+      template_file = 'impl_%s.darttemplate' % self._html_interface_name
       template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('dart_implementation.darttemplate')
 
     class_name = self._ImplClassName(self._interface.id)
     members_emitter = self._dart_impl_emitter.Emit(
         template,
         CLASSNAME=class_name,
         EXTENDS=' extends ' + self._BaseClassName(),
-        IMPLEMENTS=' implements ' + html_interface_name,
+        IMPLEMENTS=' implements ' + self._html_interface_name,
         NATIVESPEC='')
     members_emitter.Emit(''.join(self._members_emitter.Fragments()))
 
     self._GenerateCppHeader()
 
     self._cpp_impl_emitter.Emit(
         self._system._templates.Load('cpp_implementation.template'),
         INTERFACE=self._interface.id,
         INCLUDES=_GenerateCPPIncludes(self._cpp_impl_includes),
         CALLBACKS=self._cpp_definitions_emitter.Fragments(),
@@ skipping 592 matching lines @@
 
 def _IsArgumentOptionalInWebCore(argument):
   return IsOptional(argument) and not 'Callback' in argument.ext_attrs
 
 def _ToWebKitName(name):
   name = name[0].lower() + name[1:]
   name = re.sub(r'^(hTML|uRL|jS|xML|xSLT)', lambda s: s.group(1).lower(),
                 name)
   return re.sub(r'^(create|exclusive)', lambda s: 'is' + s.group(1).capitalize(),
                 name)