Revert "Dartium w/ JsInterop enabled"

tools/dom/scripts/htmldartgenerator.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 system to generate
 dart:html APIs from the IDL database."""
 
 import emitter
 from generator import AnalyzeOperation, ConstantOutputOrder, \
     DartDomNameOfAttribute, FindMatchingAttribute, IsPureInterface, \
     TypeOrNothing, ConvertToFuture, GetCallbackInfo
 from copy import deepcopy
 from htmlrenamer import convert_to_future_members, custom_html_constructors, \
     keep_overloaded_members, overloaded_and_renamed, private_html_members, \
     renamed_html_members, renamed_overloads, removed_html_members
-from generator import TypeOrVar
 import logging
 import monitored
 import sys
 
 _logger = logging.getLogger('htmldartgenerator')
 
 # Types that are accessible cross-frame in a limited fashion.
 # In these cases, the base type (e.g., WindowBase) provides restricted access
 # while the subtype (e.g., Window) provides full access to the
 # corresponding objects if there are from the same frame.
@@ skipping 290 matching lines @@
         member and not include invocation code.
     """
     # FIXME: When we pass in operations[0] below, we're assuming all
     # overloaded operations have the same security attributes.  This
     # is currently true, but we should consider filtering earlier or
     # merging the relevant data into info itself.
     method_name = self._renamer.RenameMember(self._interface.id,
                                              info.operations[0],
                                              info.name,
                                              'call:')
-
     if not method_name:
       if info.name == 'item':
         # FIXME: item should be renamed to operator[], not removed.
         self.EmitOperation(info, '_item')
       return
 
     if declare_only:
       self.DeclareOperation(info,
           self.SecureOutputType(info.type_name), method_name)
     else:
@@ skipping 182 matching lines @@
           factory_name to call (calls an autogenerated FactoryProvider
           if unspecified)
     """
     for constructor_info in constructors:
       self._AddConstructor(
           constructor_info, factory_name, factory_constructor_name)
 
   def _AddConstructor(self,
       constructor_info, factory_name, factory_constructor_name):
     # Hack to ignore the Image constructor used by JavaScript.
-    if ((self._interface.id == 'HTMLImageElement' or self._interface.id == 'Blob')
+    if (self._interface.id == 'HTMLImageElement'
       and not constructor_info.pure_dart_constructor):
       return
 
     if self.GenerateCustomFactory(constructor_info):
       return
 
     metadata = self._metadata.GetFormattedMetadata(
         self._library_name, self._interface, self._interface.id, '  ')
 
     if not factory_constructor_name:
@@ skipping 48 matching lines @@
       custom_factory_ctr = self._interface.id in _custom_factories
       constructor_full_name = constructor_info._ConstructorFullName(
           self._DartType)
 
       def GenerateCall(
           stmts_emitter, call_emitter,
           version, signature_index, argument_count):
         name = emitter.Format('_create_$VERSION', VERSION=version)
         arguments = constructor_info.idl_args[signature_index][:argument_count]
         args = None
-        call_template = ''
         if self._dart_use_blink:
             type_ids = [p.type.id for p in arguments]
             base_name, rs = \
                 self.DeriveNativeEntry("constructorCallback", 'Constructor', argument_count)
             qualified_name = \
                 self.DeriveQualifiedBlinkName(self._interface.id,
                                               base_name)
             args = constructor_info.ParametersAsArgumentList(argument_count)
-
-            # Handle converting Maps to Dictionaries, etc.
-            (factory_params, converted_arguments) = self._ConvertArgumentTypes(
-                stmts_emitter, arguments, argument_count, constructor_info)
-            args = ', '.join(converted_arguments)
-            call_template = 'wrap_jso($FACTORY_NAME($FACTORY_PARAMS))'
         else:
             qualified_name = emitter.Format(
                 '$FACTORY.$NAME',
                 FACTORY=factory_name,
                 NAME=name)
             (factory_params, converted_arguments) = self._ConvertArgumentTypes(
                 stmts_emitter, arguments, argument_count, constructor_info)
             args = ', '.join(converted_arguments)
-            call_template = '$FACTORY_NAME($FACTORY_PARAMS)'
-        call_emitter.Emit(call_template, FACTORY_NAME=qualified_name, FACTORY_PARAMS=args)
+        call_emitter.Emit('$FACTORY_NAME($FACTORY_PARAMS)',
+            FACTORY_NAME=qualified_name,
+            FACTORY_PARAMS=args)
         self.EmitStaticFactoryOverload(constructor_info, name, arguments)
 
       def IsOptional(signature_index, argument):
         return self.IsConstructorArgumentOptional(argument)
 
       entry_declaration = emitter.Format(
           '$(METADATA)$FACTORY_KEYWORD $CTOR($PARAMS)',
           FACTORY_KEYWORD=('factory' if not custom_factory_ctr else
                            'static %s' % constructor_full_name),
           CTOR=(('' if not custom_factory_ctr else '_factory')
@@ skipping 65 matching lines @@
       self._members_emitter.Emit(
           '  // To suppress missing implicit constructor warnings.\n'
           '  factory $CLASSNAME._() { '
           'throw new UnsupportedError("Not supported"); }\n',
           CLASSNAME=self._interface_type_info.implementation_name())
 
   def DeclareAttribute(self, attribute, type_name, attr_name, read_only):
     """ Declares an attribute but does not include the code to invoke it.
     """
     if read_only:
-      # HACK(terry): Element is not abstract for Dartium so isContentEditable
-      # must have a body see impl_Element.darttemplate
-      if (self._interface.id == 'Element' and
-          attr_name == 'isContentEditable' and
-          self._dart_js_interop):
-        return
-      else:
-        template = '\n  $TYPE get $NAME;\n'
+      template = '\n  $TYPE get $NAME;\n'
     else:
       template = '\n  $TYPE $NAME;\n'
 
     self._members_emitter.Emit(template,
         NAME=attr_name,
         TYPE=type_name)
 
   def DeclareOperation(self, operation, return_type_name, method_name):
     """ Declares an operation but does not include the code to invoke it.
     Arguments:
       operation - The operation to be declared.
       return_type_name - The name of the return type.
       method_name - The name of the method.
     """
-      # HACK(terry): Element is not abstract for Dartium so click
-      # must have a body see impl_Element.darttemplate
-    if (self._interface.id == 'Element' and
-        method_name == 'click' and
-        self._dart_js_interop):
-      return
-    else:
-      template = '\n  $TYPE $NAME($PARAMS);\n'
-
     self._members_emitter.Emit(
-             template,
+             '\n'
+             '  $TYPE $NAME($PARAMS);\n',
              TYPE=return_type_name,
              NAME=method_name,
              PARAMS=operation.ParametersAsDeclaration(self._DartType))
 
   def EmitListMixin(self, element_name):
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     template_file = 'immutable_list_mixin.darttemplate'
     has_length = False
     has_length_setter = False
@@ skipping 67 matching lines @@
     return self._type_registry.TypeInfo(type_name).narrow_dart_type()
 
   def _NarrowInputType(self, type_name):
     return self._NarrowToImplementationType(type_name)
 
   def _DartType(self, type_name):
     return self._type_registry.DartType(type_name)
 
   def _TypeInfo(self, type_name):
     return self._type_registry.TypeInfo(type_name)
-
-  def _ConvertArgumentTypes(self, stmts_emitter, arguments, argument_count, info):
-    temp_version = [0]
-    converted_arguments = []
-    target_parameters = []
-    for position, arg in enumerate(arguments[:argument_count]):
-      conversion = self._InputConversion(arg.type.id, info.declared_name)
-      param_name = arguments[position].id
-      if conversion:
-        temp_version[0] += 1
-        temp_name = '%s_%s' % (param_name, temp_version[0])
-        temp_type = conversion.output_type
-        stmts_emitter.Emit(
-            '$(INDENT)$TYPE $NAME = $CONVERT($ARG);\n',
-            TYPE=TypeOrVar(temp_type),
-            NAME=temp_name,
-            CONVERT=conversion.function_name,
-            ARG=info.param_infos[position].name)
-        converted_arguments.append(temp_name)
-        param_type = temp_type
-        verified_type = temp_type  # verified by assignment in checked mode.
-      else:
-        converted_arguments.append(info.param_infos[position].name)
-        param_type = self._NarrowInputType(arg.type.id)
-        # Verified by argument checking on entry to the dispatcher.
-
-        verified_type = self._InputType(
-            info.param_infos[position].type_id, info)
-        # The native method does not need an argument type if we know the type.
-        # But we do need the native methods to have correct function types, so
-        # be conservative.
-        if param_type == verified_type:
-          if param_type in ['String', 'num', 'int', 'double', 'bool', 'Object']:
-            param_type = 'dynamic'
-
-      target_parameters.append(
-          '%s%s' % (TypeOrNothing(param_type), param_name))
-
-    return target_parameters, converted_arguments
-
-  def _InputType(self, type_name, info):
-    conversion = self._InputConversion(type_name, info.declared_name)
-    if conversion:
-      return conversion.input_type
-    else:
-      return self._NarrowInputType(type_name) if type_name else 'dynamic'