- Change access pattern to Native Arguments (make one call instead of two).

tools/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 333 matching lines @@
         WEBCORE_CLASS_NAME_ESCAPED=
         self._interface_type_info.native_type().replace('<', '_').replace('>', '_'),
         DART_IMPLEMENTATION_CLASS=self._interface_type_info.implementation_name(),
         DART_IMPLEMENTATION_LIBRARY='dart:%s' % self._renamer.GetLibraryName(self._interface))
 
   def _GenerateCPPHeader(self):
     to_native_emitter = emitter.Emitter()
     if self._interface_type_info.custom_to_native():
       return_type = 'PassRefPtr<NativeType>'
       to_native_body = ';'
+      to_native_arg_body = ';'
     else:
       return_type = 'NativeType*'
       to_native_body = emitter.Format(
           '\n'
           '    {\n'
           '        return DartDOMWrapper::unwrapDartWrapper<Dart$INTERFACE>(handle, exception);\n'
           '    }',
           INTERFACE=self._interface.id)
+      to_native_arg_body = emitter.Format(
+          '\n'
+          '    {\n'
+          '        return DartDOMWrapper::unwrapDartWrapper<Dart$INTERFACE>(args, index, exception);\n'
+          '    }',
+          INTERFACE=self._interface.id)
 
     to_native_emitter.Emit(
         '    static $RETURN_TYPE toNative(Dart_Handle handle, Dart_Handle& exception)$TO_NATIVE_BODY\n'
         '\n'
         '    static $RETURN_TYPE toNativeWithNullCheck(Dart_Handle handle, Dart_Handle& exception)\n'
         '    {\n'
         '        return Dart_IsNull(handle) ? 0 : toNative(handle, exception);\n'
-        '    }\n',
+        '    }\n'
+        '\n'
+        '    static $RETURN_TYPE toNative(Dart_NativeArguments args, int index, Dart_Handle& exception)$TO_NATIVE_ARG_BODY\n'
+        '\n'
+        '    static $RETURN_TYPE toNativeWithNullCheck(Dart_NativeArguments args, int index, Dart_Handle& exception)$TO_NATIVE_ARG_BODY\n',

[vsm, 2013/08/12 20:42:07]

Why do we have both of these with the same implementation?

[siva, 2013/08/13 17:52:52]

toNativeNullCheck wants to protect against Null being passed in by
returning 0 but if you look at toNative it already does that, the two
calls are identical. It is just that the generation pattern makes it
hard to get rid of calls to 'toNativeNullCheck'

I have changed 'toNativeNullCheck to just call toNative and added a
comment.

         RETURN_TYPE=return_type,
         TO_NATIVE_BODY=to_native_body,
+        TO_NATIVE_ARG_BODY=to_native_arg_body,
         INTERFACE=self._interface.id)
 
     to_dart_emitter = emitter.Emitter()
 
     ext_attrs = self._interface.ext_attrs
 
     if ('CustomToV8' in ext_attrs or
         'PureInterface' in ext_attrs or
         'CPPPureInterface' in ext_attrs or
         self._interface_type_info.custom_to_dart()):
@@ skipping 493 matching lines @@
 
         return False
 
       if AllowsNull():
         function += 'WithNullCheck'
 
       argument_name = DartDomNameOfAttribute(argument)
       if type_info.pass_native_by_ref():
         invocation_template =\
             '        $TYPE $ARGUMENT_NAME;\n'\
-            '        $CLS::$FUNCTION(Dart_GetNativeArgument(args, $INDEX), $ARGUMENT_NAME, exception);\n'
+            '        $CLS::$FUNCTION(args, $INDEX, $ARGUMENT_NAME, exception);\n'
       else:
         invocation_template =\
-            '        $TYPE $ARGUMENT_NAME = $CLS::$FUNCTION(Dart_GetNativeArgument(args, $INDEX), exception);\n'
+            '        $TYPE $ARGUMENT_NAME = $CLS::$FUNCTION(args, $INDEX, exception);\n'
       body_emitter.Emit(
           '\n' +
           invocation_template +
           '        if (exception)\n'
           '            goto fail;\n',
           TYPE=type,
           ARGUMENT_NAME=argument_name,
           CLS=cls,
           FUNCTION=function,
           INDEX=start_index + i)
@@ skipping 49 matching lines @@
       else:
         value_expression = function_call
 
       # Generate to Dart conversion of C++ value.
       if return_type_info.dart_type() == 'bool':
         set_return_value = 'Dart_SetBooleanReturnValue(args, %s)' % (value_expression)
       elif return_type_info.dart_type() == 'int':
         set_return_value = 'Dart_SetIntegerReturnValue(args, %s)' % (value_expression)
       elif return_type_info.dart_type() == 'double':
         set_return_value = 'Dart_SetDoubleReturnValue(args, %s)' % (value_expression)
+      elif return_type_info.dart_type() == 'string':
+        set_return_value = 'DartUtilities::setDartStringReturnValue(args, %s)' % (value_expression)
       else:
         to_dart_conversion = return_type_info.to_dart_conversion(value_expression, self._interface.id, ext_attrs)
         set_return_value = 'Dart_SetReturnValue(args, %s)' % (to_dart_conversion)
       invocation_emitter.Emit(
         '        $RETURN_VALUE;\n',
         RETURN_VALUE=set_return_value)
 
   def _GenerateNativeBinding(self, idl_name, argument_count, dart_declaration,
       native_suffix, is_custom, emit_metadata=True):
     metadata = []
@@ skipping 127 matching lines @@
             '    if (Dart_NativeFunction func = $CLASS_NAME::resolver(name, argumentCount))\n'
             '        return func;\n',
             CLASS_NAME=os.path.splitext(os.path.basename(path))[0])
 
 def _IsOptionalStringArgumentInInitEventMethod(interface, operation, argument):
   return (
       interface.id.endswith('Event') and
       operation.id.startswith('init') and
       argument.ext_attrs.get('Default') == 'Undefined' and
       argument.type.id == 'DOMString')