Merging dart:html interfaces and implementations

sdk/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
 from generator import *
 from systemhtml import SecureOutputType
+from htmldartgenerator import *
 
-class DartiumBackend(object):
+class DartiumBackend(HtmlDartGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
   def __init__(self, interface, cpp_library_emitter, options):
+    super(DartiumBackend, self).__init__(interface, options)
+
     self._interface = interface
     self._cpp_library_emitter = cpp_library_emitter
     self._database = options.database
     self._template_loader = options.templates
     self._type_registry = options.type_registry
     self._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
 
   def ImplementsMergedMembers(self):
     # We could not add merged functions to implementation class because
     # underlying c++ object doesn't implement them. Merged functions are
@@ skipping 69 matching lines @@
     if interface_name == self._interface.id or not self._database.HasInterface(interface_name):
       template_file = 'impl_%s.darttemplate' % interface_name
       template = self._template_loader.TryLoad(template_file)
     if not template:
       template = self._template_loader.Load('dart_implementation.darttemplate')
     return template
 
   def RootClassName(self):
     return 'NativeFieldWrapperClass1'
 
-  def AdditionalImplementedInterfaces(self):
-    return []
-
   def NativeSpec(self):
     return ''
 
   def StartInterface(self, memebers_emitter):
     # Create emitters for c++ implementation.
     if not IsPureInterface(self._interface.id):
       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()
@@ skipping 82 matching lines @@
 
     native_binding = '%s_constructor_Callback' % self._interface.id
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         INTERFACE=interface_name,
         PARAMETERS=constructor_info.ParametersDeclaration(self._DartType),
         ARGUMENTS=constructor_info.ParametersAsArgumentList(),
         NATIVE_NAME=native_binding)
 
+  def AddConstructors(self, constructors, factory_provider, class_name,
+      base_class):
+    super(DartiumBackend, self).AddConstructors(constructors, factory_provider,
+        class_name, base_class)
+
+    super_constructor = ''
+    if base_class and base_class != 'NativeFieldWrapperClass1':
+      super_constructor = ': super.internal()'
+
+    self._members_emitter.Emit(
+        '  $CLASSNAME.internal()$SUPERCONSTRUCTOR;\n',
+        CLASSNAME=class_name,
+        SUPERCONSTRUCTOR=super_constructor)
+
   def FinishInterface(self):
     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=self._interface_type_info.implementation_name())
@@ skipping 233 matching lines @@
     if not needs_dispatcher:
       # Bind directly to native implementation
       argument_count = (0 if info.IsStatic() else 1) + len(info.param_infos)
       cpp_callback_name = self._GenerateNativeBinding(
           info.name, argument_count, dart_declaration, 'Callback', is_custom)
       if not is_custom:
         self._GenerateOperationNativeCallback(operation, operation.arguments, cpp_callback_name)
     else:
       self._GenerateDispatcher(info.operations, dart_declaration, [info.name for info in info.param_infos])
 
+  def AddConstant(self, constant):
+    type = TypeOrNothing(self._DartType(constant.type.id), constant.type.id)
+    self._members_emitter.Emit('\n  static const $TYPE$NAME = $VALUE;\n',
+        NAME=constant.id,
+        TYPE=type,
+        VALUE=constant.value)
+
   def _GenerateDispatcher(self, operations, dart_declaration, argument_names):
 
     body = self._members_emitter.Emit(
         '\n'
         '  $DECLARATION {\n'
         '$!BODY'
         '  }\n',
         DECLARATION=dart_declaration)
 
     version = [1]
@@ skipping 275 matching lines @@
         '        Dart_Handle returnValue = $TO_DART_CONVERSION;\n'
         '        if (returnValue)\n'
         '            Dart_SetReturnValue(args, returnValue);\n',
         TO_DART_CONVERSION=to_dart_conversion)
 
   def _GenerateNativeBinding(self, idl_name, argument_count, dart_declaration,
       native_suffix, is_custom):
     native_binding = '%s_%s_%s' % (self._interface.id, idl_name, native_suffix)
     self._members_emitter.Emit(
         '\n'
-        '  $DART_DECLARATION native "$NATIVE_BINDING";\n',
-        DART_DECLARATION=dart_declaration, NATIVE_BINDING=native_binding)
+        '\n  /** @domName $DOMINTERFACE.$DOMNAME */'
+        '\n  $DART_DECLARATION native "$NATIVE_BINDING";\n',
+        DOMINTERFACE=self._interface.id,
+        DOMNAME=idl_name,
+        DART_DECLARATION=dart_declaration,
+        NATIVE_BINDING=native_binding)
 
     cpp_callback_name = '%s%s' % (idl_name, native_suffix)
     self._cpp_resolver_emitter.Emit(
         '    if (argumentCount == $ARGC && name == "$NATIVE_BINDING")\n'
         '        return Dart$(INTERFACE_NAME)Internal::$CPP_CALLBACK_NAME;\n',
         ARGC=argument_count,
         NATIVE_BINDING=native_binding,
         INTERFACE_NAME=self._interface.id,
         CPP_CALLBACK_NAME=cpp_callback_name)
 
@@ skipping 88 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])