Apply html renames to native wrappers.

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
+from systemhtml import DomToHtmlEvent, DomToHtmlEvents, HtmlSystemShared
 
 class NativeImplementationSystem(System):
 
-  def __init__(self, templates, database, html_renames, emitters, auxiliary_dir,
-               output_dir):
+  def __init__(self, templates, database, html_database, html_renames,
+               emitters, auxiliary_dir, 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)
@@ skipping 195 matching lines @@
           used to avoid static member 'overriding' in the generated Dart code.
     """
     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
 
   def StartInterface(self):
     self._interface_type_info = GetIDLTypeInfo(self._interface.id)
     self._members_emitter = emitter.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()
@@ skipping 94 matching lines @@
     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)
     if parent:
       parent_events_class = '_%sEventsImpl' % parent.id
     else:
       parent_events_class = '_EventsImpl'
-    html_inteface = self._system._html_renames.get(self._interface.id, self._interface.id)
+
+    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'
         '$!MEMBERS\n'
         '}\n',
         EVENTS_CLASS=events_class,
         PARENT_EVENTS_CLASS=parent_events_class,
         EVENTS_INTERFACE='%sEvents' % html_inteface)
 
@@ skipping 55 matching lines @@
       # again.  If the operations are not specified, try to inherit from the
       # EventTarget implementation.
       #
       # Applies to MessagePort.
       if not [op for op in self._interface.operations if op.id == 'addEventListener']:
         return self._ImplClassName(supertype)
       return '_DOMWrapperBase'
 
     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
 
@@ skipping 133 matching lines @@
 
   def AddConstant(self, constant):
     # Constants are already defined on the interface.
     pass
 
   def AddAttribute(self, getter, setter):
     if 'CheckSecurityForNode' in (getter or setter).ext_attrs:
       # FIXME: exclude from interface as well.
       return
 
-    if getter:
-      self._AddGetter(getter)
-    if setter:
-      self._AddSetter(setter)
+    html_interface_name = self._HTMLInterfaceName(self._interface.id)
+    dom_name = DartDomNameOfAttribute(getter or setter)
+    html_getter_name = self._html_system.RenameInHtmlLibrary(
+        html_interface_name, dom_name, 'get:', implementation_class=True)
+    html_setter_name = self._html_system.RenameInHtmlLibrary(
+        html_interface_name, dom_name, 'set:', implementation_class=True)
+
+    if getter and html_getter_name:
+      self._AddGetter(getter, html_getter_name)
+    if setter and html_setter_name:
+      self._AddSetter(setter, html_setter_name)
 
   def AddSecondaryAttribute(self, interface, getter, setter):
     self.AddAttribute(getter, setter)
 
-  def _AddGetter(self, attr):
+  def _AddGetter(self, attr, html_name):
     type_info = GetIDLTypeInfo(attr.type.id)
-    dart_declaration = '%s get %s()' % (
-        self._DartType(attr.type.id), DartDomNameOfAttribute(attr))
+    dart_declaration = '%s get %s()' % (self._DartType(attr.type.id), html_name)
     is_custom = 'Custom' in attr.ext_attrs or 'CustomGetter' in attr.ext_attrs
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 1,
         dart_declaration, 'Getter', is_custom)
     if is_custom:
       return
 
     arguments = []
     parameter_definitions_emitter = emitter.Emitter()
     raises_exceptions = self._GenerateCallWithHandling(attr, parameter_definitions_emitter, arguments)
     raises_exceptions = raises_exceptions or attr.get_raises
@@ skipping 20 matching lines @@
                                        webcore_function_name)
       if attr.type.id.startswith('SVGAnimated'):
         webcore_function_name += 'Animated'
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     invocation = self._GenerateWebCoreInvocation(function_expression,
         arguments, attr.type.id, attr.ext_attrs, attr.get_raises)
     self._GenerateNativeCallback(cpp_callback_name, parameter_definitions_emitter.Fragments(),
         True, invocation, raises_exceptions=raises_exceptions)
 
-  def _AddSetter(self, attr):
+  def _AddSetter(self, attr, html_name):
     type_info = GetIDLTypeInfo(attr.type.id)
-    dart_declaration = 'void set %s(%s)' % (
-        DartDomNameOfAttribute(attr), self._DartType(attr.type.id))
+    dart_declaration = 'void set %s(%s)' % (html_name, self._DartType(attr.type.id))
     is_custom = set(['Custom', 'CustomSetter', 'V8CustomSetter']) & set(attr.ext_attrs)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 2,
         dart_declaration, 'Setter', is_custom)
     if is_custom:
       return
 
     arguments = []
     parameter_definitions_emitter = emitter.Emitter()
     self._GenerateCallWithHandling(attr, parameter_definitions_emitter, arguments)
 
@@ skipping 185 matching lines @@
   def _AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
 
     if 'CheckSecurityForNode' in info.overloads[0].ext_attrs:
       # FIXME: exclude from interface as well.
       return
 
-    parameters = info.ParametersImplementationDeclaration(self._DartType)
-    if 'Custom' in info.overloads[0].ext_attrs:
-      dart_declaration = '%s %s(%s)' % (self._DartType(info.type_name), info.name, parameters)
-      argument_count = (0 if info.IsStatic() else 1) + len(info.param_infos)
-      self._GenerateNativeBinding(info.name, argument_count, dart_declaration,
-          'Callback', True)
+    html_interface_name = self._HTMLInterfaceName(self._interface.id)
+    html_name = self._html_system.RenameInHtmlLibrary(
+        html_interface_name, info.name, implementation_class=True)
+
+    if not html_name and info.name == 'item':
+      # FIXME: item should be renamed to operator[], not removed.
+      html_name = 'item'
+
+    if not html_name:
       return
 
-    modifier = ''
-    if info.IsStatic():
-      modifier = 'static '
+    dart_declaration = '%s%s %s(%s)' % (
+        'static ' if info.IsStatic() else '',
+        self._DartType(info.type_name),
+        html_name or info.name,
+        info.ParametersImplementationDeclaration(self._DartType))
+
+    if 'Custom' in info.overloads[0].ext_attrs:
+      argument_count = (0 if info.IsStatic() else 1) + len(info.param_infos)
+      self._GenerateNativeBinding(info.name , argument_count,
+          dart_declaration, 'Callback', True)
+      return
+
     body = self._members_emitter.Emit(
         '\n'
-        '  $MODIFIER$TYPE $NAME($PARAMETERS) {\n'
+        '  $DECLARATION {\n'
         '$!BODY'
         '  }\n',
-        MODIFIER=modifier,
-        TYPE=self._DartType(info.type_name),
-        NAME=info.name,
-        PARAMETERS=parameters)
+        DECLARATION=dart_declaration)
 
     self._native_version = 0
     overloads = self.CombineOverloads(info.overloads)
     fallthrough = self.GenerateDispatch(body, info, '    ', overloads)
     if fallthrough:
       body.Emit('    throw "Incorrect number or type of arguments";\n');
 
   def CombineOverloads(self, overloads):
     # Combine overloads that can be implemented by the same native method.  This
     # undoes the expansion of optional arguments into multiple overloads unless
@@ skipping 402 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