Remove unused code and templates.

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
 
 class NativeImplementationSystem(System):
 
   def __init__(self, templates, database, html_database, html_renames,
-               emitters, auxiliary_dir, output_dir):
+               emitters, output_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
 
     self._html_renames = html_renames
-    self._auxiliary_dir = auxiliary_dir
-    self._dom_public_files = []
     self._dom_impl_files = []
     self._cpp_header_files = []
     self._cpp_impl_files = []
     self._html_system = HtmlSystemShared(html_database)
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     interface_name = interface.id
 
-    dart_interface_path = self._FilePathForDartInterface(interface_name)
-    self._dom_public_files.append(dart_interface_path)
-
     if IsPureInterface(interface_name):
       return None
 
     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(self, interface,
         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)
-    self._dom_public_files.append(dart_interface_path)
-
     if IsPureInterface(self._interface.id):
       return None
 
     cpp_impl_includes = set()
     cpp_header_handlers_emitter = emitter.Emitter()
     cpp_impl_handlers_emitter = emitter.Emitter()
     class_name = 'Dart%s' % self._interface.id
     for operation in interface.operations:
       if operation.type.id == 'void':
         return_prefix = ''
@@ skipping 49 matching lines @@
     cpp_impl_path = self._FilePathForCppImplementation(self._interface.id)
     self._cpp_impl_files.append(cpp_impl_path)
     cpp_impl_emitter = self._emitters.FileEmitter(cpp_impl_path)
     cpp_impl_emitter.Emit(
         self._templates.Load('cpp_callback_implementation.template'),
         INCLUDES=_GenerateCPPIncludes(cpp_impl_includes),
         INTERFACE=self._interface.id,
         HANDLERS=cpp_impl_handlers_emitter.Fragments())
 
   def GenerateLibraries(self):
-    auxiliary_dir = os.path.relpath(self._auxiliary_dir, self._output_dir)
-
-    # Generate dom_public.dart.
-    self._GenerateLibFile(
-        'dom_public.darttemplate',
-        os.path.join(self._output_dir, 'dom_public.dart'),
-        self._dom_public_files,
-        AUXILIARY_DIR=MassagePath(auxiliary_dir));
-
-    # Generate dom_impl.dart.
-    self._GenerateLibFile(
-        'dom_impl.darttemplate',
-        os.path.join(self._output_dir, 'dom_impl.dart'),
-        self._dom_impl_files,
-        AUXILIARY_DIR=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()
       for impl_file in self._cpp_impl_files[i::partitions]:
           path = os.path.relpath(impl_file, os.path.dirname(derived_sources_path))
@@ skipping 19 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 _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)
 
@@ skipping 223 matching lines @@
     return self._ImplClassName(supertype)
 
   def _HTMLInterfaceName(self, interface_name):
     return self._system._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):
-    factory_provider = '_%sFactoryProvider' % interface_name
     implementation_class = '_%sFactoryProviderImpl' % interface_name
     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)
-
-    parameters = constructor_info.ParametersImplementationDeclaration(self._DartType)
-
-    emitter = self._system._emitters.FileEmitter(dart_impl_path)
-    emitter.Emit(
-        template,
-        FACTORY_PROVIDER=factory_provider,
-        CONSTRUCTOR=interface_name,
-        PARAMETERS=parameters,
-        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)
+
+    parameters = constructor_info.ParametersImplementationDeclaration(self._DartType)
     emitter = self._system._emitters.FileEmitter(dart_impl_path)
     emitter.Emit(
         'class $IMPL_CLASS {\n'
         '  static $TYPE $IMPL_FUNCTION($PARAMETERS)\n'
         '      native "$NATIVE_NAME";\n'
         '}',
         PARAMETERS=parameters,
         IMPL_CLASS=implementation_class,
         TYPE=self._ImplClassName(interface_name),
         IMPL_FUNCTION=implementation_function,
@@ skipping 814 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