Revert "Revert 2 CLs to get one last Dartium 34."

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
 from generator import *
 from htmldartgenerator import *
-from idlnode import IDLArgument, IDLAttribute
+from idlnode import IDLArgument, IDLAttribute, IDLEnum
 from systemhtml import js_support_checks, GetCallbackInfo, HTML_LIBRARY_NAMES
 
 # This is an ugly hack to get things working on the M35 roll.  Once we
 # generate dart:blink from the new scripts, this shouldn't be needed.
 _cpp_resolver_string_map = {
     # These custom constructors all resolve to a common entry, so choosing any
     # of the generated strings works.
     'Blob_constructorCallback_RESOLVER_STRING_3_Array_DOMString_DOMString':
         'Blob_constructorCallback_RESOLVER_STRING_0_',
     'ConsoleBase_assertCondition_Callback_RESOLVER_STRING_2_boolean_object':
         'ConsoleBase_assert_Callback_RESOLVER_STRING_2_boolean_object',
     'FormData_constructorCallback':
         'FormData_constructorCallback_RESOLVER_STRING_1_HTMLFormElement',
     'XMLHttpRequest_constructorCallback_RESOLVER_STRING_0_':
         'XMLHttpRequest_constructorCallback_RESOLVER_STRING_1_XMLHttpRequestOptions',
+    # This callback name just gets generated sligtly different and we don't
+    # want to bother fixing it.
+    'ScriptProcessorNode__setEventListener_Callback':
+        'ScriptProcessorNode_setEventListener_Callback',
+    # We don't know how to get GLenum to show up as the correct type in this
+    # script and don't want to bother fixing it the right way.
+    'WebGLDrawBuffers_drawBuffersWEBGL_Callback_RESOLVER_STRING_1_sequence<GLenum>' :
+        'WebGLDrawBuffers_drawBuffersWEBGL_Callback_RESOLVER_STRING_1_sequence<unsigned long>'
 }
 
 # TODO(vsm): This logic needs to pulled from the source IDL.  These tables are
 # an ugly workaround.
 _cpp_callback_map = {
   ('DataTransferItem', 'webkitGetAsEntry'): 'DataTransferItemFileSystem',
   ('Document', 'fonts'): 'DocumentFontFaceSet',
   ('Document', 'webkitIsFullScreen'): 'DocumentFullscreen',
   ('Document', 'webkitFullScreenKeyboardInputAllowed'): 'DocumentFullscreen',
   ('Document', 'webkitCurrentFullScreenElement'): 'DocumentFullscreen',
@@ skipping 110 matching lines @@
   ('DOMURL', '_createObjectUrlFromWebKitSourceCallback'): 'URLMediaSource',
   ('DOMURL', '_createObjectURL_2Callback'): 'URLMediaSource',
   ('DOMURL', '_createObjectURL_3Callback'): 'URLMediaStream',
 }
 
 _blink_1916_rename_map = {
   'NavigatorID': 'Navigator',
   'CanvasRenderingContext' : 'CanvasRenderingContext2D',
   'Clipboard': 'DataTransfer',
   'Player': 'AnimationPlayer',
+  'Algorithm': 'KeyAlgorithm',
+  'any': 'ScriptValue',
+  'URLUtils': 'URL',
+  'URLUtilsReadOnly': 'WorkerLocation',
+  'Path': 'Path2D'
 }
 
 _cpp_partial_map = {}
 
 _cpp_no_auto_scope_list = set([
   ('Document', 'body', 'Getter'),
   ('Document', 'getElementById', 'Callback'),
   ('Document', 'getElementsByName', 'Callback'),
   ('Document', 'getElementsByTagName', 'Callback'),
   ('Element', 'getAttribute', 'Callback'),
@@ skipping 147 matching lines @@
     return _cpp_partial_map[interface_name]
   else:
     return set([])
 
 def array_type(data_type):
     matched = re.match(r'([\w\d_\s]+)\[\]', data_type)
     if not matched:
         return None
     return matched.group(1)
 
-def TypeIdToBlinkName(interface_id):
+def TypeIdToBlinkName(interface_id, database):
+  if database.HasEnum(interface_id):
+    return "DOMString" # All enums are strings.
+
   if interface_id in _blink_1916_rename_map:
     interface_id = _blink_1916_rename_map[interface_id]
   return interface_id
 
 def _GetCPPTypeName(interface_name, callback_name, cpp_name):
   # TODO(vsm): We need to track the original IDL file name in order to recover
   # the proper CPP name.
 
   cpp_tuple = (interface_name, callback_name)
   if cpp_tuple in _cpp_callback_map:
     cpp_type_name = _cpp_callback_map[cpp_tuple]
   elif (interface_name, cpp_name) in _cpp_overloaded_callback_map:
     cpp_type_name = _cpp_overloaded_callback_map[(interface_name, cpp_name)]
   else:
     cpp_type_name = interface_name
   return cpp_type_name
 
 def DeriveQualifiedName(library_name, name):
     return library_name + "." + name
 
 def DeriveNativeName(interface_name, name, suffix):
     fields = ["Native", interface_name, name]
     if suffix != "":
         fields.append(suffix)
     return "_".join(fields)
 
-def DeriveResolverString(interface_id, operation_id, native_suffix, type_ids, is_custom=False):
+def DeriveResolverString(interface_id, operation_id, native_suffix, type_ids, database, is_custom):
     type_string = \
-        "_".join(map(TypeIdToBlinkName, type_ids))
+        "_".join(map(lambda type_id : TypeIdToBlinkName(type_id, database), type_ids))
     if native_suffix:
         operation_id = "%s_%s" % (operation_id, native_suffix)
     if is_custom:
         components = \
-            [TypeIdToBlinkName(interface_id), operation_id]
+            [TypeIdToBlinkName(interface_id, database), operation_id]
     else:
         components = \
-            [TypeIdToBlinkName(interface_id), operation_id,
+            [TypeIdToBlinkName(interface_id, database), operation_id,
              "RESOLVER_STRING", str(len(type_ids)), type_string]
     return "_".join(components)
 
 # FIXME(leafp) This should really go elsewhere.  I think the right thing
 # to do is to add support in the DartLibraries objects in systemhtml
 # for emitting top level code in libraries.  This can then just be a
 # normal use of that kind of object
 def GetNativeLibraryEmitter(emitters, template_loader, 
                             dartium_output_dir, dart_output_dir,
                             auxiliary_dir):
@@ skipping 229 matching lines @@
     else:
       argument_count = len(arguments)
 
     typed_formals = constructor_info.ParametersAsArgumentList(argument_count)
     parameters = constructor_info.ParametersAsStringOfVariables(argument_count)
     interface_name =  self._interface_type_info.interface_name()
 
     if self._dart_use_blink:
         type_ids = [p.type.id for p in arguments[:argument_count]]
         constructor_callback_id = \
-            DeriveResolverString(self._interface.id, cpp_suffix, None, type_ids, is_custom)
+            DeriveResolverString(self._interface.id, cpp_suffix, None, type_ids, self._database, is_custom)
     else:
         constructor_callback_id = self._interface.id + '_' + constructor_callback_cpp_name
 
     if self._dart_use_blink:
         # First we emit the toplevel function
         dart_native_name = \
             DeriveNativeName(self._interface.id, constructor_callback_cpp_name, "")
         if constructor_callback_id in _cpp_resolver_string_map:
             constructor_callback_id = \
                 _cpp_resolver_string_map[constructor_callback_id]
@@ skipping 404 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:
       if self._dart_use_blink:
+          is_custom = any((op.id == 'item' and 'Custom' in op.ext_attrs) for op in self._interface.operations)
           dart_native_name = \
               DeriveNativeName(self._interface.id, "NativeIndexed", "Getter")
           # First emit a toplevel function to do the native call
           # Calls to this are emitted elsewhere,
           resolver_string = \
               DeriveResolverString(self._interface.id, "item", "Callback",
-                                   ["unsigned long"])
+                                   ["unsigned long"], self._database, is_custom)
           if resolver_string in _cpp_resolver_string_map:
               resolver_string = \
                   _cpp_resolver_string_map[resolver_string]
           self._native_library_emitter.Emit(
               '\n'
               '$(DART_NATIVE_NAME)(mthis, index) '
               'native "$(RESOLVER_STRING)";\n',
               DART_NATIVE_NAME = dart_native_name,
               RESOLVER_STRING=resolver_string)
 
@@ skipping 118 matching lines @@
     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)
       if self._dart_use_blink:
           type_ids = [argument.type.id
                       for argument in operation.arguments[:len(info.param_infos)]]
           resolver_string = \
               DeriveResolverString(self._interface.id, operation.id,
-                                   native_suffix, type_ids, is_custom)
+                                   native_suffix, type_ids, self._database, is_custom)
       else:
           resolver_string = None
       cpp_callback_name = self._GenerateNativeBinding(
         info.name, argument_count, dart_declaration,
         info.IsStatic(), return_type, parameters,
         native_suffix, is_custom, auto_scope_setup, 
         resolver_string=resolver_string)
       if not is_custom:
         self._GenerateOperationNativeCallback(operation, operation.arguments, cpp_callback_name, auto_scope_setup)
     else:
@@ skipping 15 matching lines @@
           static = True
           if not operation.is_static:
             actuals = ['mthis'] + actuals
           actuals_s = ", ".join(actuals)
           dart_declaration = '%s(%s)' % (
             base_name, actuals_s)
           type_ids = [argument.type.id
                       for argument in operation.arguments[:argument_count]]
           resolver_string = \
               DeriveResolverString(self._interface.id, operation.id,
-                                   native_suffix, type_ids)
+                                   native_suffix, type_ids, self._database, is_custom)
       else:
           base_name = '_%s_%s' % (operation.id, version)
           overload_name = base_name
           static = operation.is_static
           actuals_s = ", ".join(actuals)
           dart_declaration = '%s%s %s(%s)' % (
             'static ' if static else '',
             return_type,
             overload_name, actuals_s)
           resolver_string = None
@@ skipping 441 matching lines @@
           self._renamer.GetLibraryName(self._interface),
           self._interface, idl_name, '  ')
     dart_native_name = \
         DeriveNativeName(self._interface.id, idl_name, native_suffix)
 
     if (resolver_string):
         native_binding = resolver_string
     else:
         native_binding_id = self._interface.id
         if self._dart_use_blink:
-          native_binding_id = TypeIdToBlinkName(native_binding_id)
+          native_binding_id = TypeIdToBlinkName(native_binding_id, self._database)
         native_binding = \
             '%s_%s_%s' % (native_binding_id, idl_name, native_suffix)
 
     if self._dart_use_blink:
         if not static:
             formals = ", ".join(['mthis'] + parameters)
             actuals = ", ".join(['this'] + parameters)
         else:
             formals = ", ".join(parameters)
             actuals = ", ".join(parameters)
@@ skipping 286 matching lines @@
     e.Emit("};\n");
     e.Emit('\n');
     e.Emit('} // namespace WebCore\n');
 
 def _IsOptionalStringArgumentInInitEventMethod(interface, operation, argument):
   return (
       interface.id.endswith('Event') and
       operation.id.startswith('init') and
       argument.ext_attrs.get('Default') == 'Undefined' and
       argument.type.id == 'DOMString')