Extract common logic for emitting implementation classes.

lib/html/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 10 matching lines @@
     self._template_loader = options.templates
     self._type_registry = options.type_registry
     self._html_interface_name = options.renamer.RenameInterface(self._interface)
 
   def HasImplementation(self):
     return not IsPureInterface(self._interface.id)
 
   def ImplementationClassName(self):
     return self._ImplClassName(self._interface.id)
 
-  def SetImplementationEmitter(self, implementation_emitter):
-    self._dart_impl_emitter = implementation_emitter
-
   def ImplementsMergedMembers(self):
     # 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.
     return False
 
   def CustomJSMembers(self):
     return {}
 
   def GenerateCallback(self, info):
@@ skipping 49 matching lines @@
         INTERFACE=self._interface.id,
         HANDLERS=cpp_header_handlers_emitter.Fragments())
 
     cpp_impl_emitter = self._cpp_library_emitter.CreateSourceEmitter(self._interface.id)
     cpp_impl_emitter.Emit(
         self._template_loader.Load('cpp_callback_implementation.template'),
         INCLUDES=self._GenerateCPPIncludes(cpp_impl_includes),
         INTERFACE=self._interface.id,
         HANDLERS=cpp_impl_handlers_emitter.Fragments())
 
-  def StartInterface(self):
+  def ImplementationTemplate(self):
+    template = None
+    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._template_loader.TryLoad(template_file)
+    if not template:
+      template = self._template_loader.Load('dart_implementation.darttemplate')
+    return template
+
+  def AdditionalImplementedInterfaces(self):
+    return []
+
+  def NativeSpec(self):
+    return ''
+
+  def StartInterface(self, memebers_emitter):
     # Create emitters for c++ implementation.
     if self.HasImplementation():
       self._cpp_header_emitter = self._cpp_library_emitter.CreateHeaderEmitter(self._interface.id)
       self._cpp_impl_emitter = self._cpp_library_emitter.CreateSourceEmitter(self._interface.id)
     else:
       self._cpp_header_emitter = emitter.Emitter()
       self._cpp_impl_emitter = emitter.Emitter()
 
     self._interface_type_info = self._TypeInfo(self._interface.id)
-    self._members_emitter = emitter.Emitter()
+    self._members_emitter = memebers_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):
     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',
@@ skipping 31 matching lines @@
         False,
         function_expression,
         self._interface,
         constructor_info.idl_args,
         self._interface.id,
         'ConstructorRaisesException' in ext_attrs)
 
   def _ImplClassName(self, interface_name):
     return '_%sImpl' % interface_name
 
-  def _BaseClassName(self):
+  def BaseClassName(self):
     root_class = 'NativeFieldWrapperClass1'
 
     if not self._interface.parents:
       return root_class
 
     supertype = self._interface.parents[0].type.id
 
     if IsPureInterface(supertype):    # The class is a root.
       return root_class
 
@@ skipping 34 matching lines @@
     native_binding = '%s_constructor_Callback' % self._interface.id
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         INTERFACE=self._html_interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
         ARGUMENTS=constructor_info.ParametersAsArgumentList(),
         NATIVE_NAME=native_binding)
 
   def FinishInterface(self):
-    template = None
-    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._template_loader.TryLoad(template_file)
-    if not template:
-      template = self._template_loader.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 ' + self._html_interface_name,
-        NATIVESPEC='')
-    members_emitter.Emit(''.join(self._members_emitter.Fragments()))
-
     self._GenerateCPPHeader()
 
     self._cpp_impl_emitter.Emit(
         self._template_loader.Load('cpp_implementation.template'),
         INTERFACE=self._interface.id,
         INCLUDES=self._GenerateCPPIncludes(self._cpp_impl_includes),
         CALLBACKS=self._cpp_definitions_emitter.Fragments(),
         RESOLVER=self._cpp_resolver_emitter.Fragments(),
-        DART_IMPLEMENTATION_CLASS=class_name)
+        DART_IMPLEMENTATION_CLASS=self.ImplementationClassName())
 
   def _GenerateCPPHeader(self):
     to_native_emitter = emitter.Emitter()
     if self._interface_type_info.custom_to_native():
       to_native_emitter.Emit(
           '    static PassRefPtr<NativeType> toNative(Dart_Handle handle, Dart_Handle& exception);\n')
     else:
       to_native_emitter.Emit(
           '    static NativeType* toNative(Dart_Handle handle, Dart_Handle& exception)\n'
           '    {\n'
@@ skipping 629 matching lines @@
   def EmitResolver(self, template, output_dir):
     file_path = os.path.join(output_dir, 'DartResolver.cpp')
     includes_emitter, body_emitter = self._emitters.FileEmitter(file_path).Emit(template)
     for header_file in self._headers_list:
       path = os.path.relpath(header_file, output_dir)
       includes_emitter.Emit('#include "$PATH"\n', PATH=path)
       body_emitter.Emit(
           '    if (Dart_NativeFunction func = $CLASS_NAME::resolver(name, argumentCount))\n'
           '        return func;\n',
           CLASS_NAME=os.path.splitext(os.path.basename(path))[0])