Make per-interface generators an implementation detail of a system.

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
 import systembase
 from generator import *
 from systemhtml import DomToHtmlEvent, DomToHtmlEvents, HtmlSystemShared
 from systemhtml import HtmlElementConstructorInfos
 from systemhtml import EmitHtmlElementFactoryConstructors
 
 class NativeImplementationSystem(systembase.System):
 
   def __init__(self, templates, database, emitters, output_dir):
     super(NativeImplementationSystem, self).__init__(
         templates, database, emitters, output_dir)
 
     self._dom_impl_files = []
     self._cpp_header_files = []
     self._cpp_impl_files = []
     self._html_system = HtmlSystemShared(database)
     self._factory_provider_emitters = {}
 
-  def InterfaceGenerator(self,
-                         interface,
-                         common_prefix,
-                         super_interface_name,
-                         source_filter):
+  def ProcessInterface(self, interface):
     interface_name = interface.id
 
     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,
+    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)
+        self._templates).Generate()
 
   def ProcessCallback(self, interface, info):
     self._interface = interface
 
     if IsPureInterface(self._interface.id):
       return None
 
     cpp_impl_includes = set()
     cpp_header_handlers_emitter = emitter.Emitter()
     cpp_impl_handlers_emitter = emitter.Emitter()
@@ skipping 140 matching lines @@
           been converted to Dart types (e.g. int, String), unless they are in
           the same package as the interface.
       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.
     """
-    super(NativeImplementationGenerator, self).__init__(system._database)
+    super(NativeImplementationGenerator, self).__init__(
+        system._database, interface)
     self._system = system
-    self._interface = 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
     self._html_system = self._system._html_system
     self._html_renames = self._html_system._html_renames
 
   def StartInterface(self):
@@ skipping 72 matching lines @@
     for (i, argument) in enumerate(constructor_info.idl_args):
       argument_expression = self._GenerateToNative(
           parameter_definitions_emitter, argument, i)
       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, ext_attrs, raises_dom_exceptions)
 
     runtime_check = None
-    database = self._system._database
+    database = self._database
     assert (not (
       'synthesizedV8EnabledPerContext' in ext_attrs and
       'synthesizedV8EnabledAtRuntime' in ext_attrs))
     if 'synthesizedV8EnabledPerContext' in ext_attrs:
       raises_exceptions = True
       self._cpp_impl_includes.add('"ContextFeatures.h"')
       runtime_check = emitter.Format(
           '        if (!ContextFeatures::$(FEATURE)Enabled(DartUtilities::domWindowForCurrentIsolate()->document())) {\n'
           '            exception = Dart_NewString("Feature $FEATURE is not enabled");\n'
           '            goto fail;\n'
@@ skipping 32 matching lines @@
       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:
       return
 
     def IsEventTarget(interface):
       return ('EventTarget' in interface.ext_attrs and
               interface.id != 'EventTarget')
-    is_root = not _FindParent(self._interface, self._system._database, IsEventTarget)
+    is_root = not _FindParent(self._interface, self._database, IsEventTarget)
     if is_root:
       self._members_emitter.Emit('  _EventsImpl _on;\n')
 
     if not events_attributes:
       if is_root:
         self._EmitEventGetter('_EventsImpl')
       return
 
     events_class = '_%sEventsImpl' % self._interface.id
     self._EmitEventGetter(events_class)
 
     def HasEventAttributes(interface):
       return any([a.type.id == 'EventListener' for a in interface.attributes])
-    parent = _FindParent(self._interface, self._system._database, HasEventAttributes)
+    parent = _FindParent(self._interface, self._database, HasEventAttributes)
     if parent:
       parent_events_class = '_%sEventsImpl' % parent.id
     else:
       parent_events_class = '_EventsImpl'
 
     html_inteface = self._HTMLInterfaceName(self._interface.id)
     events_members = self._dart_impl_emitter.Emit(
         '\n'
         'class $EVENTS_CLASS extends $PARENT_EVENTS_CLASS implements $EVENTS_INTERFACE {\n'
         '  $EVENTS_CLASS(_ptr) : super(_ptr);\n'
@@ skipping 78 matching lines @@
         template,
         FACTORYPROVIDER='_%sFactoryProvider' % html_interface_name,
         INTERFACE=html_interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
         ARGUMENTS=constructor_info.ParametersAsArgumentList(),
         NATIVE_NAME=native_implementation_function)
 
   def FinishInterface(self):
     html_interface_name = self._HTMLInterfaceName(self._interface.id)
     template = None
-    if html_interface_name == self._interface.id or not self._system._database.HasInterface(html_interface_name):
+    if html_interface_name == self._interface.id or not self._database.HasInterface(html_interface_name):
       template_file = 'impl_%s.darttemplate' % html_interface_name
       template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.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(),
@@ skipping 34 matching lines @@
           '    static Dart_Handle toDart(NativeType* value);\n')
     else:
       to_dart_emitter.Emit(
           '    static Dart_Handle toDart(NativeType* value)\n'
           '    {\n'
           '        return DartDOMWrapper::toDart<Dart$(INTERFACE)>(value);\n'
           '    }\n',
           INTERFACE=self._interface.id)
 
     webcore_includes = _GenerateCPPIncludes(self._interface_type_info.webcore_includes())
-    wrapper_type = _DOMWrapperType(self._system._database, self._interface)
+    wrapper_type = _DOMWrapperType(self._database, self._interface)
     self._cpp_header_emitter.Emit(
         self._templates.Load('cpp_header.template'),
         INTERFACE=self._interface.id,
         WEBCORE_INCLUDES=webcore_includes,
         WEBCORE_CLASS_NAME=self._interface_type_info.native_type(),
         DECLARATIONS=self._cpp_declarations_emitter.Fragments(),
         NATIVE_TRAITS_TYPE='DartDOMWrapper::%sTraits' % wrapper_type,
         TO_NATIVE=to_native_emitter.Fragments(),
         TO_DART=to_dart_emitter.Fragments())
 
@@ skipping 548 matching lines @@
 
 def _IsArgumentOptionalInWebCore(argument):
   return IsOptional(argument) and not 'Callback' in argument.ext_attrs
 
 def _ToWebKitName(name):
   name = name[0].lower() + name[1:]
   name = re.sub(r'^(hTML|uRL|jS|xML|xSLT)', lambda s: s.group(1).lower(),
                 name)
   return re.sub(r'^(create|exclusive)', lambda s: 'is' + s.group(1).capitalize(),
                 name)