Rework Element constructors

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
 from generator import *
 from systembase import *
 from systemhtml import DomToHtmlEvent, DomToHtmlEvents, HtmlSystemShared
+from systemhtml import HtmlElementConstructorInfos
+from systemhtml import EmitHtmlElementFactoryConstructors
 
 class NativeImplementationSystem(System):
 
   def __init__(self, templates, database, html_database, html_renames,
                emitters, output_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
 
     self._html_renames = html_renames
     self._dom_impl_files = []
     self._cpp_header_files = []
     self._cpp_impl_files = []
     self._html_system = HtmlSystemShared(html_database)
+    self._factory_provider_emitters = {}
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     interface_name = interface.id
 
     if IsPureInterface(interface_name):
       return None
@@ skipping 132 matching lines @@
   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]
+
   def DartImplementationFiles(self):
     return self._dom_impl_files
 
 
 class NativeImplementationGenerator(object):
   """Generates Dart implementation for one DOM IDL interface."""
 
   def __init__(self, system, interface,
                dart_impl_emitter, cpp_header_emitter, cpp_impl_emitter,
                base_members, templates):
@@ skipping 27 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()
     self._GenerateEvents()
 
   def _GenerateConstructors(self):
+    html_interface_name = self._HTMLInterfaceName(self._interface.id)
+    infos = HtmlElementConstructorInfos(html_interface_name)
+    if infos:
+      self._EmitHtmlElementFactoryConstructors(infos, html_interface_name)
+
     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)
 
@@ skipping 47 matching lines @@
       arguments.append(argument_expression)
 
     function_expression = '%s::%s' % (self._interface_type_info.native_type(), create_function)
     invocation = self._GenerateWebCoreInvocation(function_expression, arguments,
         self._interface.id, self._interface.ext_attrs, raises_dom_exceptions)
     self._GenerateNativeCallback(callback_name='constructorCallback',
         parameter_definitions=parameter_definitions_emitter.Fragments(),
         needs_receiver=False, invocation=invocation,
         raises_exceptions=raises_exceptions)
 
+  def _EmitHtmlElementFactoryConstructors(self, infos, html_interface_name):
+    EmitHtmlElementFactoryConstructors(
+        self._system._EmitterForFactoryProviderBody(
+            infos[0].factory_provider_name),
+        infos,
+        html_interface_name,
+        html_interface_name)
+
   def _GenerateEvents(self):
     if self._interface.id == 'DocumentFragment':
       # Interface DocumentFragment extends Element in dart:html but this fact
       # is not reflected in idls.
       self._EmitEventGetter('_ElementEventsImpl')
       return
 
     events_attributes = [attr for attr in self._interface.attributes
                          if attr.type.id == 'EventListener']
     if not 'EventTarget' in self._interface.ext_attrs and not events_attributes:
@@ skipping 866 matching lines @@
   for parent in interface.parents:
     parent_name = parent.type.id
     if not database.HasInterface(parent.type.id):
       continue
     parent_interface = database.GetInterface(parent.type.id)
     if callback(parent_interface):
       return parent_interface
     parent_interface = _FindParent(parent_interface, database, callback)
     if parent_interface:
       return parent_interface