Changed to use JSInterop

tools/dom/scripts/generator.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 systems to generate
 Dart APIs from the IDL database."""
 
 import copy
 import json
@@ skipping 496 matching lines @@
     def param_name(param_info):
       if self.requires_named_arguments and param_info.is_optional:
         return '%s : %s' % (param_info.name, param_info.name)
       else:
         return param_info.name
 
     if parameter_count is None:
       parameter_count = len(self.param_infos)
     return ', '.join(map(param_name, self.param_infos[:parameter_count]))
 
-  def ParametersAsListOfVariables(self, parameter_count=None):
+  def wrap_unwrap_list_blink(self, return_type, type_registry):
+    """Return True if the type is a List<Node>"""
+    return return_type.startswith('List<Node>')
+
+  def wrap_unwrap_type_blink(self, return_type, type_registry):
+    """Returns True if the type is a blink type that requires wrap_jso or unwrap_jso.
+    Notice we look for any class that starts with HtmlNNNN e.g., HtmlDocument, etc. """
+    return (type_registry.HasInterface(return_type) or not(return_type) or
+            return_type == 'Object' or return_type.startswith('Html') or
+            return_type == 'MutationObserver')
+
+  def ParametersAsListOfVariables(self, parameter_count=None, type_registry=None):
     """Returns a list of the first parameter_count parameter names
     as raw variables.
     """
     if parameter_count is None:
       parameter_count = len(self.param_infos)
-    return [p.name for p in self.param_infos[:parameter_count]]
+    if not type_registry:
+      return [p.name for p in self.param_infos[:parameter_count]]
+    else:
+      parameters = []
+      for p in self.param_infos[:parameter_count]:
+        type_id = p.type_id
+        # 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.
+        if (self.wrap_unwrap_type_blink(type_id, type_registry)):
+          if type_id == 'EventListener' and (self.name == 'addEventListener' or self.name == 'addListener'):
+            # Events fired need to wrap the Javascript Object passed as a parameter in event.
+            parameters.append('unwrap_jso((Event event) => %s(wrap_jso(event)))' % p.name)
+          else:
+            parameters.append('unwrap_jso(%s)' % p.name)
+        else:
+          passParam = p.name
+          if type_id == 'Dictionary':
+            # Need to pass the IDL Dictionary from Dart Map to JavaScript object.
+            passParam = '{0} != null ? new js.JsObject.jsify({0}) : {0}'.format(p.name)
+          parameters.append(passParam)
+
+      return parameters
 
   def ParametersAsStringOfVariables(self, parameter_count=None):
     """Returns a string containing the first parameter_count parameter names
     as raw variables, comma separated.
     """
     return ', '.join(self.ParametersAsListOfVariables(parameter_count))
 
   def IsStatic(self):
     is_static = self.overloads[0].is_static
     assert any([is_static == o.is_static for o in self.overloads])
@@ skipping 741 matching lines @@
 _svg_supplemental_includes = [
     '"core/svg/properties/SVGPropertyTraits.h"',
 ]
 
 class TypeRegistry(object):
   def __init__(self, database, renamer=None):
     self._database = database
     self._renamer = renamer
     self._cache = {}
 
+  def HasInterface(self, type_name):
+    return self._database.HasInterface(type_name)
+
   def TypeInfo(self, type_name):
     if not type_name in self._cache:
       self._cache[type_name] = self._TypeInfo(type_name)
     return self._cache[type_name]
 
   def DartType(self, type_name):
     return self.TypeInfo(type_name).dart_type()
 
   def _TypeInfo(self, type_name):
     match = re.match(r'(?:sequence<([\w ]+)>|(\w+)\[\])$', type_name)
@@ skipping 49 matching lines @@
     if type_data.clazz == 'BasicTypedList':
       if type_name == 'ArrayBuffer':
         dart_interface_name = 'ByteBuffer'
       else:
         dart_interface_name = self._renamer.RenameInterfaceId(type_name)
       return BasicTypedListIDLTypeInfo(
           type_name, type_data, dart_interface_name, self)
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)