Extract common logic for element factory constructors generation.

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."""
 
 import emitter
 
@@ skipping 869 matching lines @@
         DOMNAME=self._interface.doc_js_name)
 
     for constructor_info in constructors:
       self._members_emitter.Emit(
           '\n'
           '  $CTOR($PARAMS);\n',
           CTOR=self._shared.DartType(constructor_info.ConstructorFullName()),
           PARAMS=constructor_info.ParametersInterfaceDeclaration(
                      self._shared.DartType));
 
+    if infos:
+      EmitHtmlElementFactoryConstructors(
+          self._system._backend._EmitterForFactoryProviderBody(
+              infos[0].factory_provider_name),
+          infos,
+          self._html_interface_name,
+          self._backend.ImplementationClassName())
+
     element_type = MaybeTypedArrayElementTypeInHierarchy(
         self._interface, self._system._database)
     if element_type:
       self._members_emitter.Emit(
           '\n'
           '  $CTOR(int length);\n'
           '\n'
           '  $CTOR.fromList(List<$TYPE> list);\n'
           '\n'
           '  $CTOR.fromBuffer(ArrayBuffer buffer,'
@@ skipping 128 matching lines @@
     super(HtmlFrogClassGenerator, self).__init__(
         system, interface, None, None)
     self._shared = self._system._shared
     self._html_interface_name = self._shared._HTMLInterfaceName(
         self._interface.id)
 
   def HasImplementation(self):
     return not (IsPureInterface(self._interface.id) or
                 self._interface.id in _merged_html_interfaces)
 
+  def ImplementationClassName(self):
+    return self._ImplClassName(self._html_interface_name)
+
   def FilePathForDartImplementation(self):
     return os.path.join(self._system._output_dir, 'html', 'frog',
                         '%s.dart' % self._html_interface_name)
 
   def SetImplementationEmitter(self, implementation_emitter):
     self._dart_code = implementation_emitter
 
   def _ImplClassName(self, type_name):
     return self._shared._ImplClassName(type_name)
 
@@ skipping 44 matching lines @@
         NATIVESPEC=' native "' + native_spec + '"')
     if self._members_emitter == None:
       raise Exception("Class %s doesn't use the $!MEMBERS variable" %
                       self._class_name)
 
     # Emit a factory provider class for the constructor.
     constructor_info = AnalyzeConstructor(interface)
     if constructor_info:
       self._EmitFactoryProvider(constructor_info)
 
-    infos = HtmlElementConstructorInfos(self._html_interface_name)
-    if infos:
-      self._EmitHtmlElementFactoryConstructors(infos)
-
     emit_events, events = self._shared.GetEventAttributes(self._interface)
     if not emit_events:
       return
     elif events:
       self.AddEventAttributes(events)
     else:
       parent_events_class = self._shared.GetParentEventsClass(self._interface)
       self._EmitEventGetter('_' + parent_events_class + 'Impl')
 
     for merged_interface in _merged_html_interfaces:
@@ skipping 10 matching lines @@
     factory_provider = '_' + self._html_interface_name + 'FactoryProvider'
     emitter = self._system._ImplFileEmitter(factory_provider)
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=self._html_interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
         NAMED_CONSTRUCTOR=constructor_info.name or self._html_interface_name,
         ARGUMENTS=constructor_info.ParametersAsArgumentList())
 
-  def _EmitHtmlElementFactoryConstructors(self, infos):
-    EmitHtmlElementFactoryConstructors(
-        self._system._EmitterForFactoryProviderBody(
-            infos[0].factory_provider_name),
-        infos,
-        self._html_interface_name, self._class_name)
-
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
     # We would like to simply inherit the implementation of everything except
     # get length(), [], and maybe []=.  It is possible to extend from a base
     # array implementation class only when there is no other implementation
     # inheritance.  There might be no implementation inheritance other than
     # DOMBaseWrapper for many classes, but there might be some where the
     # array-ness is introduced by a non-root interface:
     #
     #   interface Y extends X, List<T> ...
@@ skipping 257 matching lines @@
             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