Support ImplementedBy idl attribute.

client/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
@@ skipping 286 matching lines @@
         parameter_definitions = (
             '        ScriptExecutionContext* context = DartUtilities::scriptExecutionContext();\n'
             '        if (!context) {\n'
             '            exception = Dart_NewString("Failed to create an object");\n'
             '            goto fail;\n'
             '        }\n')
         arguments = ['context']
       else:
         raise Exception('Unsupported CallWith=%s attribute' % call_with)
 
+    if raises_dom_exceptions:
+      arguments.append('ec')
+
+    invocation = '%s::create(%s)' % (type_info.native_type(), ', '.join(arguments))
     self._GenerateNativeCallback(
         callback_name='constructorCallback',
         idl_node=self._interface,
         parameter_definitions=parameter_definitions,
-        needs_receiver=False, function_name='%s::create' % type_info.native_type(),
-        arguments=arguments,
+        needs_receiver=False,
+        invocation=invocation,
         idl_return_type=self._interface,
         raises_dart_exceptions=raises_dart_exceptions,
         raises_dom_exceptions=raises_dom_exceptions)
 
-
   def _ImplClassName(self, interface_name):
     return interface_name + 'Implementation'
 
   def _IsConstructable(self):
     # FIXME: support ConstructorTemplate.
     return set(['CustomConstructor', 'V8CustomConstructor', 'Constructor']) & set(self._interface.ext_attrs)
 
   def FinishInterface(self):
     base = self._BaseClassName(self._interface)
     self._dart_impl_emitter.Emit(
@@ skipping 47 matching lines @@
         DECLARATIONS=self._cpp_declarations_emitter.Fragments())
 
   def AddAttribute(self, getter, setter):
     # FIXME: Dartium does not support attribute event listeners. However, JS
     # implementation falls back to them when addEventListener is not available.
     # Make sure addEventListener is available in all EventTargets and remove
     # this check.
     if (getter or setter).type.id == 'EventListener':
       return
 
-    # FIXME: support 'ImplementedBy'.
-    if 'ImplementedBy' in (getter or setter).ext_attrs:
-      return
-
     # FIXME: these should go away.
     classes_with_unsupported_custom_getters = [
         'Clipboard', 'Console', 'Coordinates', 'DeviceMotionEvent',
         'DeviceOrientationEvent', 'FileReader', 'JavaScriptCallFrame',
         'HTMLInputElement', 'HTMLOptionsCollection', 'HTMLOutputElement',
         'ScriptProfileNode', 'WebKitAnimation']
     if (self._interface.id in classes_with_unsupported_custom_getters and
         getter and set(['Custom', 'CustomGetter']) & set(getter.ext_attrs)):
       return
 
@@ skipping 27 matching lines @@
       else:
         webcore_function_name = re.sub(r'^(HTML|URL|JS|XML|XSLT|\w)',
                                        lambda s: s.group(1).lower(),
                                        attr.id)
         webcore_function_name = re.sub(r'^(create|exclusive)',
                                        lambda s: 'is' + s.group(1).capitalize(),
                                        webcore_function_name)
       if attr.type.id.startswith('SVGAnimated'):
         webcore_function_name += 'Animated'
 
+    invocation = self._GenerateWebCoreInvocation(attr, webcore_function_name,
+        arguments, attr.get_raises)
     self._GenerateNativeCallback(cpp_callback_name, attr, '',
-        True, webcore_function_name, arguments, idl_return_type=attr.type,
+        True, invocation, idl_return_type=attr.type,
         raises_dart_exceptions=attr.get_raises,
         raises_dom_exceptions=attr.get_raises)
 
   def _AddSetter(self, attr):
     dart_declaration = 'void set %s(%s)' % (attr.id, 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 = []
     if 'Reflect' in attr.ext_attrs:
       webcore_function_name = GetIDLTypeInfo(attr.type).webcore_setter_name()
       arguments.append(self._GenerateWebCoreReflectionAttributeName(attr))
     else:
       webcore_function_name = re.sub(r'^(xml(?=[A-Z])|\w)',
                                      lambda s: s.group(1).upper(),
                                      attr.id)
       webcore_function_name = 'set%s' % webcore_function_name
       if attr.type.id.startswith('SVGAnimated'):
         webcore_function_name += 'Animated'
 
     arguments.append(attr.id)
+
     parameter_definitions_emitter = emitter.Emitter()
     self._GenerateParameterAdapter(parameter_definitions_emitter, attr, 0)
     parameter_definitions = parameter_definitions_emitter.Fragments()
+    invocation = self._GenerateWebCoreInvocation(attr, webcore_function_name,
+        arguments, attr.set_raises)
     self._GenerateNativeCallback(cpp_callback_name, attr, parameter_definitions,
-        True, webcore_function_name, arguments, idl_return_type=None,
+        True, invocation, idl_return_type=None,
         raises_dart_exceptions=True,
         raises_dom_exceptions=attr.set_raises)
 
   def _HasNativeIndexGetter(self, interface):
     return ('CustomIndexedGetter' in interface.ext_attrs or
             'NumericIndexedGetter' in interface.ext_attrs)
 
   def _EmitNativeIndexGetter(self, interface, element_type):
     dart_declaration = '%s operator[](int index)' % element_type
     self._GenerateNativeBinding('numericIndexGetter', 2, dart_declaration,
@@ skipping 39 matching lines @@
   def GenerateSingleOperation(self,  dispatch_emitter, info, indent, operation):
     """Generates a call to a single operation.
 
     Arguments:
       dispatch_emitter: an dispatch_emitter for the body of a block of code.
       info: the compound information about the operation and its overloads.
       indent: an indentation string for generated code.
       operation: the IDLOperation to call.
     """
 
-    # FIXME: support ImplementedBy callbacks.
-    if 'ImplementedBy' in operation.ext_attrs:
-      return
-
     for op in self._interface.operations:
       if op.id != operation.id or len(op.arguments) <= len(operation.arguments):
         continue
       next_argument = op.arguments[len(operation.arguments)]
       if next_argument.is_optional and 'Callback' in next_argument.ext_attrs:
         # FIXME: '[Optional, Callback]' arguments could be non-optional in
         # webcore. We need to fix overloads handling to generate native
         # callbacks properly.
         return
 
@@ skipping 20 matching lines @@
     dart_declaration = '%s _%s(%s)' % (info.type_name, native_name,
                                        argument_list)
     is_custom = 'Custom' in operation.ext_attrs
     cpp_callback_name = self._GenerateNativeBinding(
         native_name, 1 + len(operation.arguments), dart_declaration, 'Callback',
         is_custom)
     if is_custom:
       return
 
     # Generate callback.
-    webcore_function_name = operation.id
-    if 'ImplementedAs' in operation.ext_attrs:
-      webcore_function_name = operation.ext_attrs['ImplementedAs']
+    webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
 
     parameter_definitions_emitter = emitter.Emitter()
     raises_dart_exceptions = len(operation.arguments) > 0 or operation.raises
     arguments = []
 
     # Process 'CallWith' argument.
     if 'CallWith' in operation.ext_attrs:
       call_with = operation.ext_attrs['CallWith']
       if call_with == 'ScriptExecutionContext':
         parameter_definitions_emitter.Emit(
@@ skipping 35 matching lines @@
       if len(operation.arguments) == 2:
         arguments.append('false')
 
     if self._interface.id == 'CSSStyleDeclaration' and operation.id == 'setProperty':
       # CSSStyleDeclaration.setProperty priority parameter is optional in Dart
       # idl, but is not optional in webcore implementation.
       if len(operation.arguments) == 2:
         arguments.append('String()')
 
     if 'NeedsUserGestureCheck' in operation.ext_attrs:
-      arguments.extend('DartUtilities::processingUserGesture')
+      arguments.append('DartUtilities::processingUserGesture')
 
-    parameter_definitions = parameter_definitions_emitter.Fragments()
-    self._GenerateNativeCallback(cpp_callback_name, operation, parameter_definitions,
-        True, webcore_function_name, arguments, idl_return_type=operation.type,
+    invocation = self._GenerateWebCoreInvocation(operation,
+        webcore_function_name, arguments, operation.raises)
+    self._GenerateNativeCallback(cpp_callback_name, operation,
+        parameter_definitions=parameter_definitions_emitter.Fragments(),
+        needs_receiver=True, invocation=invocation,
+        idl_return_type=operation.type,
         raises_dart_exceptions=raises_dart_exceptions,
         raises_dom_exceptions=operation.raises)
 
   def _GenerateNativeCallback(self, callback_name, idl_node,
-      parameter_definitions, needs_receiver, function_name, arguments, idl_return_type,
+      parameter_definitions, needs_receiver, invocation, idl_return_type,
       raises_dart_exceptions, raises_dom_exceptions):
-    if raises_dom_exceptions:
-      arguments.append('ec')
-    prefix = ''
-    if needs_receiver: prefix = self._interface_type_info.receiver()
-    callback = '%s%s(%s)' % (prefix, function_name, ', '.join(arguments))
+
+    callback = invocation
 
     nested_templates = []
     if idl_return_type and idl_return_type.id != 'void':
       return_type_info = GetIDLTypeInfo(idl_return_type)
       conversion_cast = return_type_info.conversion_cast('$BODY')
       if isinstance(return_type_info, SVGTearOffIDLTypeInfo):
         svg_primitive_types = ['SVGAngle', 'SVGLength', 'SVGMatrix',
             'SVGNumber', 'SVGPoint', 'SVGRect', 'SVGTransform']
         conversion_cast = '%s::create($BODY)'
         if self._interface.id.startswith('SVGAnimated'):
@@ skipping 120 matching lines @@
     namespace = 'HTMLNames'
     svg_exceptions = ['class', 'id', 'onabort', 'onclick', 'onerror', 'onload',
                       'onmousedown', 'onmousemove', 'onmouseout', 'onmouseover',
                       'onmouseup', 'onresize', 'onscroll', 'onunload']
     if self._interface.id.startswith('SVG') and not attr.id in svg_exceptions:
       namespace = 'SVGNames'
     self._cpp_impl_includes[namespace] = 1
 
     attribute_name = attr.ext_attrs['Reflect'] or attr.id.lower()
     return 'WebCore::%s::%sAttr' % (namespace, attribute_name)
+
+  def _GenerateWebCoreInvocation(self, idl_node, function_name, arguments,
+                                 raises_dom_exceptions):

[antonm, 2012/02/24 19:01:40]

I don't like how ec handling is now spread all over the code base.  May we
invent something better?  Let's discuss on Mon

+    if 'ImplementedBy' in idl_node.ext_attrs:
+      implementedBy = idl_node.ext_attrs['ImplementedBy']
+      self._cpp_impl_includes[implementedBy] = 1
+      invocation = '%s::%s' % (implementedBy, function_name)
+      arguments.insert(0, 'receiver')
+    else:
+      invocation = '%s%s' % (self._interface_type_info.receiver(), function_name)
+
+    if raises_dom_exceptions:
+      arguments.append('ec')
+
+    return '%s(%s)' % (invocation, ', '.join(arguments))