Dartium w/ JsInterop enabled

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 376 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 _InputConversion(self, type_name, info):
-    return None
+  def _InputConversion(self, idl_type, member):
+    return FindConversion(idl_type, 'set', self._interface.id, member)
 
   def GenerateCallback(self, info):
     if IsPureInterface(self._interface.id) or IsCustomType(self._interface.id):
       return
 
     interface = self._interface
     if interface.parents:
       supertype = '%sClassId' % interface.parents[0].type.id
     else:
       supertype = '-1'
@@ skipping 229 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) => '
-            '$TOPLEVEL_NAME($OUTPARAMETERS);\n',
+            'wrap_jso($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,
@@ skipping 248 matching lines @@
 
   def _GenerateAutoSetupScope(self, idl_name, native_suffix):
     return (self._interface.id, idl_name, native_suffix) not in _cpp_no_auto_scope_list
 
   def _AddGetter(self, attr, html_name, read_only):
     # Temporary hack to force dart:scalarlist clamped array for ImageData.data.
     # TODO(antonm): solve in principled way.
     if self._interface.id == 'ImageData' and html_name == 'data':
       html_name = '_data'
     type_info = self._TypeInfo(attr.type.id)
-    return_type = self.SecureOutputType(attr.type.id, False, read_only)
+    return_type = self.SecureOutputType(attr.type.id, False, False if self._dart_use_blink else True)
     parameters = []
     dart_declaration = '%s get %s' % (return_type, html_name)
     is_custom = _IsCustom(attr) and (_IsCustomValue(attr, None) or
                                      _IsCustomValue(attr, 'Getter'))
 
     # Operation uses blink?
     wrap_unwrap_list = [];
     return_wrap_jso = False
     if self._dart_use_blink:
         # 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 = (isinstance(type_info, InterfaceIDLTypeInfo) or
-                           not(type_info) or attr.type.id == 'Object')
+        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
 
     # 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)
@@ skipping 42 matching lines @@
     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']
 
-    dart_declaration = 'void set %s(%s value)' % (html_name, ptype)
+    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)
     native_entry = \
         self.DeriveNativeEntry(attr.id, 'Setter', None)
@@ skipping 69 matching lines @@
       # 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):
+      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;
   }
 
   $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_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 = \
@@ skipping 71 matching lines @@
     dart_declaration = 'void operator[]=(%s)' % formals
     self._GenerateNativeBinding('numericIndexSetter', 3,
       dart_declaration, False, return_type, parameters,
       'Callback', True, False)
 
   def EmitOperation(self, info, html_name, dart_js_interop=False):
     """
     Arguments:
       info: An OperationInfo object.
     """
-    return_type = self.SecureOutputType(info.type_name, False, True)
+    return_type = self.SecureOutputType(info.type_name, False, False if dart_js_interop else True)
 
     formals = info.ParametersAsDeclaration(self._DartType)
 
-    parameters = info.ParametersAsListOfVariables(None, self._type_registry if self._dart_use_blink else None, dart_js_interop)
+    parameters = info.ParametersAsListOfVariables(None,
+                                                  self._type_registry if self._dart_use_blink else None,
+                                                  dart_js_interop)
     dart_declaration = '%s%s %s(%s)' % (
         'static ' if info.IsStatic() else '',
         return_type,
         html_name,
         formals)
 
     operation = info.operations[0]
 
     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 = (info.wrap_unwrap_type_blink(return_type, self._type_registry) or
-                           return_type == 'Rectangle' or
-                           info.wrap_unwrap_list_blink(return_type, self._type_registry))
-    wrap_unwrap_list.append(return_wrap_jso)       # wrap_jso the returned object
-    wrap_unwrap_list.append(self._dart_use_blink)  # The 'this' parameter must be unwrap_jso
+        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))
@@ skipping 15 matching lines @@
       native_suffix = 'Callback'
       actuals = info.ParametersAsListOfVariables(argument_count,
                                                  self._type_registry if self._dart_use_blink else None,
                                                  self._dart_js_interop)
       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 = self._type_registry.HasInterface(return_type)
+          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
         formals = ['mthis'] + formals
       actuals_s = ", ".join(actuals)
       formals_s = ", ".join(formals)
@@ skipping 462 matching lines @@
         else:
             emit_template = '''
   $METADATA$DART_DECLARATION => $DART_NAME($ACTUALS);
   '''
             if wrap_unwrap_list and wrap_unwrap_list[0]:
                 emit_jso_template = '''
   $METADATA$DART_DECLARATION => %s($DART_NAME($ACTUALS));
   '''
                 if return_type == 'Rectangle':
                     jso_util_method = 'make_dart_rectangle'
-                # TODO(terry): More checks that the return is a List<Node>.
-                elif return_type.startswith('List<'):
-                    jso_util_method = 'wrap_jso_list'
-                else:
+                elif wrap_unwrap_list[0]:
                     jso_util_method = 'wrap_jso'
+
                 # Always return List<String> unwrapped.
                 if return_type != 'List<String>':
                   emit_template = emit_jso_template % jso_util_method
-            caller_emitter.Emit(emit_template,
-                                METADATA=metadata,
-                                DART_DECLARATION=dart_declaration,
-                                DART_NAME=full_dart_name,
-                                ACTUALS=actuals)
+
+            if caller_emitter:
+              caller_emitter.Emit(emit_template,
+                                  METADATA=metadata,
+                                  DART_DECLARATION=dart_declaration,
+                                  DART_NAME=full_dart_name,
+                                  ACTUALS=actuals)
     cpp_callback_name = '%s%s' % (idl_name, native_suffix)
 
     self._cpp_resolver_emitter.Emit(
         '    if (argumentCount == $ARGC && name == "$NATIVE_BINDING") {\n'
         '        *autoSetupScope = $AUTO_SCOPE_SETUP;\n'
         '        return Dart$(INTERFACE_NAME)Internal::$CPP_CALLBACK_NAME;\n'
         '    }\n',
         ARGC=argument_count,
         NATIVE_BINDING=native_binding,
         INTERFACE_NAME=self._interface.id,
@@ skipping 258 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