Revert "Dartium w/ JsInterop enabled"

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 149 matching lines @@
     'NodeList': 'NodeList,RadioNodeList',
 
     'OscillatorNode': 'OscillatorNode,Oscillator',
 
     'PannerNode': 'PannerNode,AudioPannerNode,webkitAudioPannerNode',
 
     'RTCPeerConnection': 'RTCPeerConnection,mozRTCPeerConnection',
 
     'RTCIceCandidate': 'RTCIceCandidate,mozRTCIceCandidate',
 
-    'RTCIceCandidateEvent': 'RTCIceCandidateEvent,RTCPeerConnectionIceEvent',
+    'RTCIceCandidateEvent': 'RTCIceCandidateEvent,RTCPeerConnectionIceEvent', 
 
     'RTCSessionDescription': 'RTCSessionDescription,mozRTCSessionDescription',
 
     'RTCDataChannel': 'RTCDataChannel,DataChannel',
 
     'ScriptProcessorNode': 'ScriptProcessorNode,JavaScriptAudioNode',
 
     'TransitionEvent': 'TransitionEvent,WebKitTransitionEvent',
 
     'WebGLLoseContext': 'WebGLLoseContext,WebGLExtensionLoseContext',
@@ skipping 326 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 isCallback(self, type_registry, type_id):
-    if type_id:
-      callback_type = type_registry._database._all_interfaces[type_id]
-      return callback_type.operations[0].id == 'handleEvent' if len(callback_type.operations) > 0 else False
-    else:
-      return False
+  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, dart_js_interop=False):
     """Returns a list of the first parameter_count parameter names
     as raw variables.
     """
-    isRemoveOperation = self.name == 'removeEventListener' or self.name == 'removeListener'
-
     if parameter_count is None:
       parameter_count = len(self.param_infos)
     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 (wrap_unwrap_type_blink(type_id, type_registry)):
-          type_is_callback = self.isCallback(type_registry, type_id)
-          if (dart_js_interop and type_id == 'EventListener' and
-              (self.name == 'addEventListener')):
-              # Events fired need use a JsFunction not a anonymous closure to
-              # insure the event can really be removed.
-              parameters.append('wrap_event_listener(this, %s)' % p.name)
-          elif (dart_js_interop and type_id == 'EventListener' and
-              (self.name == 'removeEventListener')):
-              # Find the JsFunction that corresponds to this Dart function.
-              parameters.append('_knownListeners[this.hashCode][identityHashCode(%s)]' % p.name)
-          elif dart_js_interop and type_id == 'FontFaceSetForEachCallback':
-              # forEach is supported in the DOM for FontFaceSet as it iterates
-              # over the Javascript Object the callback parameters are also
-              # Javascript objects and must be wrapped.
-              parameters.append('unwrap_jso((fontFace, fontFaceAgain, set) => %s(wrap_jso(fontFace), wrap_jso(fontFaceAgain), wrap_jso(set)))' % p.name)
-          elif dart_js_interop and type_id == 'HeadersForEachCallback':
-              # forEach is supported in the DOM for Headers as it iterates
-              # over the Javascript Object the callback parameters are also
-              # Javascript objects and must be wrapped.
-              parameters.append('unwrap_jso((String value, String key, map) => %s(value, key, wrap_jso(map)))' % p.name)
-          elif dart_js_interop and type_is_callback and not(isRemoveOperation):
-            # Any remove operation that has a a callback doesn't need wrapping.
-            # TODO(terry): Kind of hacky but handles all the cases we care about
-            callback_type = type_registry._database._all_interfaces[type_id]
-            callback_args_decl = []
-            callback_args_call = []
-            for callback_arg in callback_type.operations[0].arguments:
-              if dart_js_interop:
-                dart_type = '' # For non-primitives we will be passing JsObject for non-primitives, so ignore types
-              else:
-                dart_type = type_registry.DartType(callback_arg.type.id) + ' '
-              callback_args_decl.append('%s%s' % (dart_type, callback_arg.id))
-              if wrap_unwrap_type_blink(callback_arg.type.id, type_registry):
-                callback_args_call.append('wrap_jso(%s)' % callback_arg.id)
-              else:
-                callback_args_call.append(callback_arg.id)
-            parameters.append('unwrap_jso((%s) => %s(%s))' %
-                              (", ".join(callback_args_decl),
-                               p.name,
-                               ", ".join(callback_args_call)))
+        if (self.wrap_unwrap_type_blink(type_id, type_registry)):
+          if dart_js_interop and 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:
           if dart_js_interop:
             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)
           else:
             passParam = p.name
@@ skipping 826 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)
-
-def wrap_unwrap_list_blink(return_type, type_registry):
-    """Return True if the type is a List<Node>"""
-    return return_type.startswith('List<Node>')
-
-def wrap_unwrap_type_blink(return_type, type_registry):
-    """Returns True if the type is a blink type that requires wrap_jso or
-    unwrap_jso"""
-    if return_type and return_type.startswith('Html'):
-        return_type = return_type.replace('Html', 'HTML', 1)
-    return (type_registry.HasInterface(return_type) or not(return_type) or
-            return_type == 'Object' or
-            return_type == 'Future' or
-            return_type == 'SqlDatabase' or # renamed to Database
-            return_type == 'HTMLElement' or
-            return_type == 'MutationObserver')
-
-def wrap_type_blink(return_type, type_registry):
-    """Returns True if the type is a blink type that requires wrap_jso but
-    NOT unwrap_jso"""
-    return (return_type == 'Map' or
-            return_type == 'Rectangle')
-
-def wrap_return_type_blink(return_type, type_name, type_registry):
-    """Returns True if we should wrap the returned value. This checks
-    a number of different variations, calling the more basic functions
-    above."""
-    return (wrap_unwrap_type_blink(return_type, type_registry) or
-            wrap_unwrap_type_blink(type_name, type_registry) or
-            wrap_type_blink(return_type, type_registry) or
-            wrap_unwrap_list_blink(return_type, type_registry))