Generate factory providers for systemnative

client/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
@@ skipping 28 matching lines @@
 
     dart_impl_path = self._FilePathForDartImplementation(interface_name)
     self._dom_impl_files.append(dart_impl_path)
 
     cpp_header_path = self._FilePathForCppHeader(interface_name)
     self._cpp_header_files.append(cpp_header_path)
 
     cpp_impl_path = self._FilePathForCppImplementation(interface_name)
     self._cpp_impl_files.append(cpp_impl_path)
 
-    return NativeImplementationGenerator(interface, super_interface_name,
+    return NativeImplementationGenerator(self, interface, super_interface_name,
         self._emitters.FileEmitter(dart_impl_path),
         self._emitters.FileEmitter(cpp_header_path),
         self._emitters.FileEmitter(cpp_impl_path),
         self._BaseDefines(interface),
         self._templates)
 
   def ProcessCallback(self, interface, info):
     self._interface = interface
 
     dart_interface_path = self._FilePathForDartInterface(self._interface.id)
@@ skipping 110 matching lines @@
     pass
 
   def _FilePathForDartInterface(self, interface_name):
     return os.path.join(self._output_dir, 'src', 'interface',
                         '%s.dart' % interface_name)
 
   def _FilePathForDartImplementation(self, interface_name):
     return os.path.join(self._output_dir, 'dart',
                         '%sImplementation.dart' % interface_name)
 
+  def _FilePathForDartFactoryProvider(self, interface_name):
+    return os.path.join(self._output_dir, 'dart',
+                        '_%sFactoryProvider.dart' % interface_name)
+
+  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)
 
 
 class NativeImplementationGenerator(systemwrapping.WrappingInterfaceGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
-  def __init__(self, interface, super_interface,
+  def __init__(self, system, interface, super_interface,
                dart_impl_emitter, cpp_header_emitter, cpp_impl_emitter,
                base_members, templates):
     """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_interface: A string or None, the name of the common interface that
          this interface implements, if any.
       dart_impl_emitter: an Emitter for the file containing the Dart
          implementation class.
       cpp_header_emitter: an Emitter for the file containing the C++ header.
       cpp_impl_emitter: an Emitter for the file containing the C++
          implementation.
       base_members: a set of names of members defined in a base class.  This is
           used to avoid static member 'overriding' in the generated Dart code.
     """
+    self._system = system
     self._interface = interface
     self._super_interface = super_interface
     self._dart_impl_emitter = dart_impl_emitter
     self._cpp_header_emitter = cpp_header_emitter
     self._cpp_impl_emitter = cpp_impl_emitter
     self._base_members = base_members
     self._templates = templates
     self._current_secondary_parent = None
 
   def StartInterface(self):
@@ skipping 13 matching lines @@
 
     # 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)
+
     if constructor_info is None:
       # We have a custom implementation for it.
       self._cpp_declarations_emitter.Emit(
           '\n'
           'void constructorCallback(Dart_NativeArguments);\n')
       return
 
     raises_dom_exceptions = 'ConstructorRaisesException' in self._interface.ext_attrs
     raises_exceptions = raises_dom_exceptions or len(constructor_info.idl_args) > 0
     arguments = []
@@ skipping 38 matching lines @@
         needs_receiver=False, invocation=invocation,
         raises_exceptions=raises_exceptions)
 
   def _ImplClassName(self, interface_name):
     return interface_name + 'Implementation'
 
   def _IsConstructable(self):
     # FIXME: support ConstructorTemplate.
     return set(['CustomConstructor', 'V8CustomConstructor', 'Constructor', 'NamedConstructor']) & set(self._interface.ext_attrs)
 
+  def _EmitFactoryProvider(self, interface_name, constructor_info):
+    factory_provider = '_' + interface_name + 'FactoryProvider'
+    implementation_class = interface_name + 'FactoryProviderImplementation'
+    implementation_function = 'create' + interface_name
+    native_implementation_function = '%s_constructor_Callback' % interface_name
+
+    # Emit private factory provider in public library.
+    template_file = 'factoryprovider_%s.darttemplate' % interface_name
+    template = self._system._templates.TryLoad(template_file)
+    if not template:
+      template = self._system._templates.Load('factoryprovider.darttemplate')
+
+    dart_impl_path = self._system._FilePathForDartFactoryProvider(
+        interface_name)
+    self._system._dom_public_files.append(dart_impl_path)
+
+    emitter = self._system._emitters.FileEmitter(dart_impl_path)
+    emitter.Emit(
+        template,
+        FACTORY_PROVIDER=factory_provider,
+        CONSTRUCTOR=interface_name,
+        PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
+        IMPL_CLASS=implementation_class,
+        IMPL_FUNCTION=implementation_function,
+        ARGUMENTS=constructor_info.ParametersAsArgumentList())
+
+    # Emit public implementation in implementation libary.
+    dart_impl_path = self._system._FilePathForDartFactoryProviderImplementation(
+        interface_name)
+    self._system._dom_impl_files.append(dart_impl_path)
+    emitter = self._system._emitters.FileEmitter(dart_impl_path)
+    emitter.Emit(
+        'class $IMPL_CLASS {\n'
+        '  static $INTERFACE_NAME $IMPL_FUNCTION($PARAMETERS)\n'
+        '      native "$NATIVE_NAME";\n'
+        '}',
+        INTERFACE_NAME=interface_name,
+        PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
+        IMPL_CLASS=implementation_class,
+        IMPL_FUNCTION=implementation_function,
+        NATIVE_NAME=native_implementation_function)
+
   def FinishInterface(self):
     base = self._BaseClassName(self._interface)
     self._dart_impl_emitter.Emit(
         self._templates.Load('dart_implementation.darttemplate'),
         CLASS=self._class_name, BASE=base, INTERFACE=self._interface.id,
         MEMBERS=self._members_emitter.Fragments())
 
     self._GenerateCppHeader()
 
     self._cpp_impl_emitter.Emit(
@@ skipping 466 matching lines @@
 
     if 'ImplementedBy' in attributes:
       arguments.insert(0, 'receiver')
       self._cpp_impl_includes.add(attributes['ImplementedBy'])
 
     return emitter.Format(invocation_template,
         FUNCTION_CALL='%s(%s)' % (function_expression, ', '.join(arguments)))
 
 def _GenerateCPPIncludes(includes):
   return ''.join(['#include "%s.h"\n' % include for include in includes])