Optimize dartium dart:html bindings so real world application performance is acceptable. Improves d…

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 logging
 import os
 from generator import *
 from htmldartgenerator import *
 from idlnode import IDLArgument, IDLAttribute, IDLEnum, IDLMember
 from systemhtml import js_support_checks, GetCallbackInfo, HTML_LIBRARY_NAMES
 
 _logger = logging.getLogger('systemnative')
 
 # TODO(vsm): This should be recoverable from IDL, but we appear to not
 # track the necessary info.
 _url_utils = ['hash', 'host', 'hostname', 'origin',
               'password', 'pathname', 'port', 'protocol',
               'search', 'username']
 
+_promise_to_future = Conversion('convertNativePromiseToDartFuture', 'dynamic', 'Future')
+
 def array_type(data_type):
     matched = re.match(r'([\w\d_\s]+)\[\]', data_type)
     if not matched:
         return None
     return matched.group(1)
 
 _sequence_matcher = re.compile('sequence\<(.+)\>')
 
 def TypeIdToBlinkName(interface_id, database):
   # Maybe should use the type_registry here?
@@ skipping 66 matching lines @@
 
   def ImplementsMergedMembers(self):
     # We could not add merged functions to implementation class because
     # underlying c++ object doesn't implement them. Merged functions are
     # generated on merged interface implementation instead.
     return False
 
   def CustomJSMembers(self):
     return {}
 
+  def _OutputConversion(self, idl_type, member):
+    conversion = FindConversion(idl_type, 'get', self._interface.id, member)
+    # TODO(jacobr) handle promise consistently in dart2js and dartium.
+    if idl_type == 'Promise':
+      return _promise_to_future
+    if conversion:
+      if conversion.function_name in ('_convertNativeToDart_Window', '_convertNativeToDart_EventTarget', 'convertNativeToDart_DateTime', 'convertNativeToDart_ImageData'):
+        return None
+    return conversion
+
   def _InputConversion(self, idl_type, member):
     return FindConversion(idl_type, 'set', self._interface.id, member)
 
   def GenerateCallback(self, info):
     return None
 
   def ImplementationTemplate(self):
     template = None
     interface_name = self._interface.doc_js_name
     if interface_name == self._interface.id or not self._database.HasInterface(interface_name):
@@ skipping 122 matching lines @@
 
     # Then we emit the impedance matching wrapper to call out to the
     # toplevel wrapper
     if not emit_to_native:
         toplevel_name = \
             self.DeriveQualifiedBlinkName(self._interface.id,
                                           dart_native_name)
         self._members_emitter.Emit(
             '\n  @DocsEditable()\n'
             '  static $INTERFACE_NAME $FACTORY_METHOD_NAME($PARAMETERS) => '
-            'wrap_jso($TOPLEVEL_NAME($OUTPARAMETERS));\n',
+            '$TOPLEVEL_NAME($OUTPARAMETERS);\n',
             INTERFACE_NAME=self._interface_type_info.interface_name(),
             FACTORY_METHOD_NAME=factory_method_name,
             PARAMETERS=typed_formals,
             TOPLEVEL_NAME=toplevel_name,
             OUTPARAMETERS=parameters)
 
     self._cpp_resolver_emitter.Emit(
         '    if (name == "$ID")\n'
         '        return Dart$(WEBKIT_INTERFACE_NAME)Internal::$CPP_CALLBACK;\n',
         ID=constructor_callback_id,
         WEBKIT_INTERFACE_NAME=self._interface.id,
         CPP_CALLBACK=constructor_callback_cpp_name)
 
   def GenerateCustomFactory(self, constructor_info):
     if 'CustomConstructor' not in self._interface.ext_attrs:
         return False
 
     annotations = self._metadata.GetFormattedMetadata(self._library_name,
         self._interface, self._interface.id, '  ')
 
     self._members_emitter.Emit(
-        '\n  $(ANNOTATIONS)factory $CTOR($PARAMS) => wrap_jso(_create($FACTORY_PARAMS));\n',
+        '\n  $(ANNOTATIONS)factory $CTOR($PARAMS) => _create($FACTORY_PARAMS);\n',
         ANNOTATIONS=annotations,
         CTOR=constructor_info._ConstructorFullName(self._DartType),
         PARAMS=constructor_info.ParametersAsDeclaration(self._DartType),
         FACTORY_PARAMS= \
             constructor_info.ParametersAsArgumentList())
 
     # MutationObserver has custom _create.  TODO(terry): Consider table but this is only one.
     if self._interface.id != 'MutationObserver':
         constructor_callback_cpp_name = 'constructorCallback'
         self._EmitConstructorInfrastructure(
@@ skipping 243 matching lines @@
         # Unwrap the type to get the JsObject if Type is:
         #
         #    - known IDL type
         #    - type_id is None then it's probably a union type or overloaded
         #      it's a dynamic/any type
         #    - type is Object
         #
         # JsObject maybe stored in the Dart class.
         return_wrap_jso = wrap_return_type_blink(return_type, attr.type.id, self._type_registry)
     wrap_unwrap_list.append(return_wrap_jso)       # wrap_jso the returned object
-    wrap_unwrap_list.append(self._dart_use_blink)  # this must be unwrap_jso
+    wrap_unwrap_list.append(self._dart_use_blink) 
 
     # This seems to have been replaced with Custom=Getter (see above), but
     # check to be sure we don't see the old syntax
     assert(not ('CustomGetter' in attr.ext_attrs))
     native_suffix = 'Getter'
     auto_scope_setup = self._GenerateAutoSetupScope(attr.id, native_suffix)
     native_entry = \
         self.DeriveNativeEntry(attr.id, 'Getter', None)
+    output_conversion = self._OutputConversion(attr.type.id, attr.id)
+
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 1,
         dart_declaration, attr.is_static, return_type, parameters,
         native_suffix, is_custom, auto_scope_setup, native_entry=native_entry,
-        wrap_unwrap_list=wrap_unwrap_list, dictionary_return=dictionary_returned)
+        wrap_unwrap_list=wrap_unwrap_list, dictionary_return=dictionary_returned,
+        output_conversion=output_conversion)
     if is_custom:
       return
 
     if 'Reflect' in attr.ext_attrs:
       webcore_function_name = self._TypeInfo(attr.type.id).webcore_getter_name()
       if 'URL' in attr.ext_attrs:
         if 'NonEmpty' in attr.ext_attrs:
           webcore_function_name = 'getNonEmptyURLAttribute'
         else:
           webcore_function_name = 'getURLAttribute'
@@ skipping 14 matching lines @@
               attr.ext_attrs['RaisesException'] != 'Setter')
 
   def _AddSetter(self, attr, html_name):
     return_type = 'void'
     ptype = self._DartType(attr.type.id)
 
     type_info = self._TypeInfo(attr.type.id)
 
     # Is the setter value a DartClass (that has a JsObject) or the type is
     # None (it's a dynamic/any type) then unwrap_jso before passing to blink.
-    parameters = ['unwrap_jso(value)' if (isinstance(type_info, InterfaceIDLTypeInfo) or
-                                          not(attr.type.id) or ptype == 'Object')
-                  else 'value']
+    parameters = ['value']
 
     dart_declaration = 'set %s(%s value)' % (html_name, ptype)
     is_custom = _IsCustom(attr) and (_IsCustomValue(attr, None) or
                                      _IsCustomValue(attr, 'Setter'))
     # This seems to have been replaced with Custom=Setter (see above), but
     # check to be sure we don't see the old syntax
     assert(not ('CustomSetter' in attr.ext_attrs))
     assert(not ('V8CustomSetter' in attr.ext_attrs))
     native_suffix = 'Setter'
     auto_scope_setup = self._GenerateAutoSetupScope(attr.id, native_suffix)
@@ skipping 45 matching lines @@
     #
     #   class YImpl extends ListBase<T> { copies of transitive XImpl methods; }
     #
     dart_element_type = self._DartType(element_type)
     if self._HasNativeIndexGetter():
       self._EmitNativeIndexGetter(dart_element_type)
     elif self._HasExplicitIndexedGetter():
       self._EmitExplicitIndexedGetter(dart_element_type)
     else:
       is_custom = any((op.id == 'item' and _IsCustom(op)) for op in self._interface.operations)
+
+      output_conversion = self._OutputConversion(element_type, 'item')
+      conversion_name = ''
+      if output_conversion:
+        conversion_name = output_conversion.function_name
+
       # First emit a toplevel function to do the native call
       # Calls to this are emitted elsewhere,
       dart_native_name, resolver_string = \
           self.DeriveNativeEntry("item", 'Method', 1)
 
       # Emit the method which calls the toplevel function, along with
       # the [] operator.
       dart_qualified_name = \
           self.DeriveQualifiedBlinkName(self._interface.id,
                                         dart_native_name)
 
       type_info = self._TypeInfo(element_type)
-      # Does nativeIndexGetter return a DartClass (JsObject) if so wrap_jso.
-      wrap_jso_start = ''
-      wrap_jso_end = ''
-      if (isinstance(type_info, InterfaceIDLTypeInfo) or
-          wrap_type_blink(type_info.narrow_dart_type(), self._type_registry)):
-          wrap_jso_start = 'wrap_jso('
-          wrap_jso_end = ')'
       blinkNativeIndexed = """
   $TYPE operator[](int index) {
     if (index < 0 || index >= length)
       throw new RangeError.index(index, this);
-    return %s$(DART_NATIVE_NAME)(unwrap_jso(this), index)%s;
+    return _nativeIndexedGetter(index);
   }
 
-  $TYPE _nativeIndexedGetter(int index) => %s$(DART_NATIVE_NAME)(unwrap_jso(this), index)%s;
-""" % (wrap_jso_start, wrap_jso_end, wrap_jso_start, wrap_jso_end)
-      # Wrap the type to store the JsObject if Type is:
-      #
-      #    - known IDL type
-      #    - type_id is None then it's probably a union type or overloaded
-      #      it's a dynamic/any type
-      #    - type is Object
-      #
-      # JsObject maybe stored in the Dart class.
-      if isinstance(type_info, InterfaceIDLTypeInfo) or not(type_info) or dart_element_type == 'Object':
-          blinkNativeIndexedGetter = \
-              ' {0}$(DART_NATIVE_NAME)(unwrap_jso(this), index){1};\n'.format('wrap_jso(', ')')
-      else:
-          blinkNativeIndexedGetter = \
-              ' $(DART_NATIVE_NAME)(unwrap_jso(this), index);\n'
+  $TYPE _nativeIndexedGetter(int index) => $(CONVERSION_NAME)($(DART_NATIVE_NAME)(this, index));
+"""
+      blinkNativeIndexedGetter = \
+          ' $(DART_NATIVE_NAME)(this, index);\n'
       self._members_emitter.Emit(blinkNativeIndexed,
                                  DART_NATIVE_NAME=dart_qualified_name,
                                  TYPE=self.SecureOutputType(element_type),
-                                 INTERFACE=self._interface.id)
+                                 INTERFACE=self._interface.id,
+                                 CONVERSION_NAME=conversion_name)
 
     if self._HasNativeIndexSetter():
       self._EmitNativeIndexSetter(dart_element_type)
     else:
       self._members_emitter.Emit(
           '\n'
           '  void operator[]=(int index, $TYPE value) {\n'
           '    throw new UnsupportedError("Cannot assign element of immutable List.");\n'
           '  }\n',
           TYPE=dart_element_type)
@@ skipping 81 matching lines @@
 
     formals = info.ParametersAsDeclaration(self._DartType)
 
     parameters = info.ParametersAsListOfVariables(None,
                                                   self._type_registry if self._dart_use_blink else None,
                                                   dart_js_interop,
                                                   self)
 
     operation = info.operations[0]
 
+    output_conversion = self._OutputConversion(operation.type.id, operation.id)
+
     dictionary_returned = False
     # Return type for dictionary is any (untyped).
     if operation.type.id == 'Dictionary':
       return_type = '';
       dictionary_returned = True;
 
     dart_declaration = '%s%s %s(%s)' % (
         'static ' if info.IsStatic() else '',
         return_type,
         html_name,
         formals)
 
     is_custom = _IsCustom(operation)
     has_optional_arguments = any(IsOptional(argument) for argument in operation.arguments)
     needs_dispatcher = not is_custom and (len(info.operations) > 1 or has_optional_arguments)
 
     # Operation uses blink?
     wrap_unwrap_list = [];
     return_wrap_jso = False
     # return type wrapped?
     if self._dart_use_blink:
         # Wrap the type to store the JsObject if Type is:
         #
-        #    - known IDL type
-        #    - type_id is None then it's probably a union type or overloaded
         #      it's a dynamic/any type
         #    - type is Object
         #
         # JsObject maybe stored in the Dart class.
         return_wrap_jso = wrap_return_type_blink(return_type, info.type_name, self._type_registry)
         return_type_info = self._type_registry.TypeInfo(info.type_name)
-        if (isinstance(return_type_info, SequenceIDLTypeInfo) and
-            not isinstance(return_type_info._item_info, PrimitiveIDLTypeInfo)):
-                return_wrap_jso = True
     # wrap_jso the returned object
     wrap_unwrap_list.append(return_wrap_jso)
-    # The 'this' parameter must be unwrap_jso
     wrap_unwrap_list.append(self._dart_use_blink)
 
     if info.callback_args:
       self._AddFutureifiedOperation(info, html_name)
     elif not needs_dispatcher:
       # Bind directly to native implementation
       argument_count = (0 if info.IsStatic() else 1) + len(info.param_infos)
       native_suffix = 'Callback'
       auto_scope_setup = self._GenerateAutoSetupScope(info.name, native_suffix)
       native_entry = \
           self.DeriveNativeEntry(operation.id, 'Method', len(info.param_infos))
       cpp_callback_name = self._GenerateNativeBinding(
         info.name, argument_count, dart_declaration,
         info.IsStatic(), return_type, parameters,
         native_suffix, is_custom, auto_scope_setup,
         native_entry=native_entry,
         wrap_unwrap_list=wrap_unwrap_list,
-        dictionary_return=dictionary_returned)
+        dictionary_return=dictionary_returned,
+        output_conversion=output_conversion)
       if not is_custom:
         self._GenerateOperationNativeCallback(operation, operation.arguments, cpp_callback_name, auto_scope_setup)
     else:
       self._GenerateDispatcher(info, info.operations, dart_declaration, html_name)
 
   def _GenerateDispatcher(self, info, operations, dart_declaration, html_name):
 
     def GenerateCall(
         stmts_emitter, call_emitter, version, operation, argument_count):
       native_suffix = 'Callback'
       actuals = info.ParametersAsListOfVariables(argument_count,
                                                  self._type_registry if self._dart_use_blink else None,
                                                  self._dart_js_interop,
                                                  self)
       actuals_s = ", ".join(actuals)
       formals=actuals
       return_type = self.SecureOutputType(operation.type.id)
 
       return_wrap_jso = False
       if self._dart_use_blink:
           return_wrap_jso = wrap_return_type_blink(return_type, info.type_name, self._type_registry)
 
       native_suffix = 'Callback'
       is_custom = _IsCustom(operation)
       base_name = '_%s_%s' % (operation.id, version)
       static = True
       if not operation.is_static:
-        actuals = ['unwrap_jso(this)' if self._dart_use_blink else 'this'] + actuals
+        actuals = ['this'] + actuals
         formals = ['mthis'] + formals
       actuals_s = ", ".join(actuals)
       formals_s = ", ".join(formals)
       dart_declaration = '%s(%s)' % (
         base_name, formals_s)
       native_entry = \
           self.DeriveNativeEntry(operation.id, 'Method', argument_count)
       overload_base_name = native_entry[0]
       overload_name = \
           self.DeriveQualifiedBlinkName(self._interface.id,
                                         overload_base_name)
-      if return_wrap_jso:
-          call_emitter.Emit('wrap_jso($NAME($ARGS))', NAME=overload_name, ARGS=actuals_s)
-      else:
-          call_emitter.Emit('$NAME($ARGS)', NAME=overload_name, ARGS=actuals_s)
+      call_emitter.Emit('$NAME($ARGS)', NAME=overload_name, ARGS=actuals_s)
       auto_scope_setup = \
         self._GenerateAutoSetupScope(base_name, native_suffix)
       cpp_callback_name = self._GenerateNativeBinding(
         base_name, (0 if static else 1) + argument_count,
         dart_declaration, static, return_type, formals,
         native_suffix, is_custom, auto_scope_setup, emit_metadata=False,
         emit_to_native=True, native_entry=native_entry)
       if not is_custom:
         self._GenerateOperationNativeCallback(operation,
           operation.arguments[:argument_count], cpp_callback_name,
@@ skipping 11 matching lines @@
     pass
 
   def _GenerateOperationNativeCallback(self, operation, arguments, cpp_callback_name, auto_scope_setup=True):
     webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, operation, cpp_callback_name)
 
   def _GenerateNativeBinding(self, idl_name, argument_count, dart_declaration,
       static, return_type, parameters, native_suffix, is_custom,
       auto_scope_setup=True, emit_metadata=True, emit_to_native=False,
-      native_entry=None, wrap_unwrap_list=[], dictionary_return=False):
+      native_entry=None, wrap_unwrap_list=[], dictionary_return=False, output_conversion=None):
     metadata = []
     if emit_metadata:
       metadata = self._metadata.GetFormattedMetadata(
           self._renamer.GetLibraryName(self._interface),
           self._interface, idl_name, '  ')
 
     if (native_entry):
         dart_native_name, native_binding = native_entry
     else:
         dart_native_name = \
             self.DeriveNativeName(idl_name, native_suffix)
         native_binding_id = self._interface.id
         native_binding_id = TypeIdToBlinkName(native_binding_id, self._database)
         native_binding = \
             '%s_%s_%s' % (native_binding_id, idl_name, native_suffix)
 
     if not static:
         formals = ", ".join(['mthis'] + parameters)
-        if wrap_unwrap_list and wrap_unwrap_list[1]:
-            actuals = ", ".join(['unwrap_jso(this)'] + parameters)
-        else:
-            actuals = ", ".join(['this'] + parameters)
+        actuals = ", ".join(['this'] + parameters)
     else:
         formals = ", ".join(parameters)
         actuals = ", ".join(parameters)
 
     if not emit_to_native:
         caller_emitter = self._members_emitter
         full_dart_name = \
             self.DeriveQualifiedBlinkName(self._interface.id,
                                           dart_native_name)
         if IsPureInterface(self._interface.id):
             caller_emitter.Emit(
                 '\n'
                 '  $METADATA$DART_DECLARATION;\n',
                 METADATA=metadata,
                 DART_DECLARATION=dart_declaration)
         else:
             emit_template = '''
   $METADATA$DART_DECLARATION => $DART_NAME($ACTUALS);
   '''
-            if wrap_unwrap_list and wrap_unwrap_list[0]:
+            if output_conversion and not dictionary_return:
+              conversion_template = '''
+  $METADATA$DART_DECLARATION => %s($DART_NAME($ACTUALS));
+  '''
+              emit_template = conversion_template % output_conversion.function_name
+
+            elif wrap_unwrap_list and wrap_unwrap_list[0]:
                 if return_type == 'Rectangle':
                     jso_util_method = 'make_dart_rectangle'
                 elif wrap_unwrap_list[0]:
-                    jso_util_method = 'wrap_jso'
+                    jso_util_method = ''
 
                 if dictionary_return:
                   emit_jso_template = '''
   $METADATA$DART_DECLARATION => convertNativeDictionaryToDartDictionary(%s($DART_NAME($ACTUALS)));
   '''
                 else:
                   emit_jso_template = '''
   $METADATA$DART_DECLARATION => %s($DART_NAME($ACTUALS));
   '''
                 emit_template = emit_jso_template % jso_util_method
@@ skipping 263 matching lines @@
 
 def _IsCustom(op_or_attr):
   assert(isinstance(op_or_attr, IDLMember))
   return 'Custom' in op_or_attr.ext_attrs or 'DartCustom' in op_or_attr.ext_attrs
 
 def _IsCustomValue(op_or_attr, value):
   if _IsCustom(op_or_attr):
     return op_or_attr.ext_attrs.get('Custom') == value \
            or op_or_attr.ext_attrs.get('DartCustom') == value
   return False