MERGE: 152953-155080

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 systemhtml import js_support_checks, GetCallbackInfo, HTML_LIBRARY_NAMES
 
-_cpp_type_map = {
+# TODO(vsm): This logic needs to pulled from the source IDL.  These tables are
+# an ugly workaround.
+_cpp_callback_map = {
   ('DataTransferItem', 'webkitGetAsEntry'): 'DataTransferItemFileSystem',
   ('Document', 'webkitIsFullScreen'): 'DocumentFullscreen',
   ('Document', 'webkitFullScreenKeyboardInputAllowed'): 'DocumentFullscreen',
   ('Document', 'webkitCurrentFullScreenElement'): 'DocumentFullscreen',
   ('Document', 'webkitCancelFullScreen'): 'DocumentFullscreen',
   ('Document', 'webkitFullscreenEnabled'): 'DocumentFullscreen',
   ('Document', 'webkitFullscreenElement'): 'DocumentFullscreen',
   ('Document', 'webkitExitFullscreen'): 'DocumentFullscreen',
-  ('Window', 'crypto'): 'DOMWindowCrypto',
-  ('Window', 'indexedDB'): 'DOMWindowIndexedDatabase',
-  ('Window', 'speechSynthesis'): 'DOMWindowSpeechSynthesis',
-  ('Window', 'webkitNotifications'): 'DOMWindowNotifications',
-  ('Window', 'storage'): 'DOMWindowQuota',
-  ('Window', 'webkitStorageInfo'): 'DOMWindowQuota',
-  ('Window', 'openDatabase'): 'DOMWindowWebDatabase',
-  ('Window', 'webkitRequestFileSystem'): 'DOMWindowFileSystem',
-  ('Window', 'webkitResolveLocalFileSystemURL'): 'DOMWindowFileSystem',
+  ('DOMWindow', 'crypto'): 'DOMWindowCrypto',
+  ('DOMWindow', 'indexedDB'): 'DOMWindowIndexedDatabase',
+  ('DOMWindow', 'speechSynthesis'): 'DOMWindowSpeechSynthesis',
+  ('DOMWindow', 'webkitNotifications'): 'DOMWindowNotifications',
+  ('DOMWindow', 'storage'): 'DOMWindowQuota',
+  ('DOMWindow', 'webkitStorageInfo'): 'DOMWindowQuota',
+  ('DOMWindow', 'openDatabase'): 'DOMWindowWebDatabase',
+  ('DOMWindow', 'webkitRequestFileSystem'): 'DOMWindowFileSystem',
+  ('DOMWindow', 'webkitResolveLocalFileSystemURL'): 'DOMWindowFileSystem',
+  ('DOMWindow', 'atob'): 'DOMWindowBase64',
+  ('DOMWindow', 'btoa'): 'DOMWindowBase64',
+  ('DOMWindow', 'clearTimeout'): 'DOMWindowTimers',
+  ('DOMWindow', 'clearInterval'): 'DOMWindowTimers',
   ('HTMLInputElement', 'webkitEntries'): 'HTMLInputElementFileSystem',
   ('Navigator', 'doNotTrack'): 'NavigatorDoNotTrack',
   ('Navigator', 'geolocation'): 'NavigatorGeolocation',
   ('Navigator', 'webkitPersistentStorage'): 'NavigatorStorageQuota',
   ('Navigator', 'webkitTemporaryStorage'): 'NavigatorStorageQuota',
   ('Navigator', 'registerProtocolHandler'): 'NavigatorContentUtils',
   ('Navigator', 'unregisterProtocolHandler'): 'NavigatorContentUtils',
   ('Navigator', 'webkitGetUserMedia'): 'NavigatorMediaStream',
   ('Navigator', 'webkitGetGamepads'): 'NavigatorGamepad',
   ('Navigator', 'requestMIDIAccess'): 'NavigatorWebMIDI',
   ('Navigator', 'vibrate'): 'NavigatorVibration',
+  ('WorkerGlobalScope', 'crypto'): 'WorkerGlobalScopeCrypto',
+  ('WorkerGlobalScope', 'indexedDB'): 'WorkerGlobalScopeIndexedDatabase',
+  ('WorkerGlobalScope', 'webkitNotifications'): 'WorkerGlobalScopeNotifications',
+  ('WorkerGlobalScope', 'openDatabase'): 'WorkerGlobalScopeWebDatabase',
+  ('WorkerGlobalScope', 'openDatabaseSync'): 'WorkerGlobalScopeWebDatabase',
+  ('WorkerGlobalScope', 'performance'): 'WorkerGlobalScopePerformance',
+  ('WorkerGlobalScope', 'webkitRequestFileSystem'): 'WorkerGlobalScopeFileSystem',
+  ('WorkerGlobalScope', 'webkitRequestFileSystemSync'): 'WorkerGlobalScopeFileSystem',
+  ('WorkerGlobalScope', 'webkitResolveLocalFileSystemURL'): 'WorkerGlobalScopeFileSystem',
+  ('WorkerGlobalScope', 'webkitResolveLocalFileSystemSyncURL'): 'WorkerGlobalScopeFileSystem',
+  ('WorkerGlobalScope', 'atob'): 'DOMWindowBase64',
+  ('WorkerGlobalScope', 'btoa'): 'DOMWindowBase64',
+  ('WorkerGlobalScope', 'clearTimeout'): 'DOMWindowTimers',
+  ('WorkerGlobalScope', 'clearInterval'): 'DOMWindowTimers',
   }
 
+_cpp_overloaded_callback_map = {
+  ('DOMURL', 'createObjectUrlFromSourceCallback'): 'URLMediaSource',
+  ('DOMURL', 'createObjectUrlFromStreamCallback'): 'URLMediaStream',
+  ('DOMURL', '_createObjectUrlFromWebKitSourceCallback'): 'URLMediaSource',
+  ('DOMURL', '_createObjectURL_2Callback'): 'URLMediaSource',
+  ('DOMURL', '_createObjectURL_3Callback'): 'URLMediaSource',
+  ('DOMURL', '_createObjectURL_4Callback'): 'URLMediaStream',
+}
+
 _cpp_partial_map = {}
 
-def _GetCPPPartialNames(interface_name):
+def _GetCPPPartialNames(interface):
+  interface_name = interface.ext_attrs.get('ImplementedAs', interface.id)
   if not _cpp_partial_map:
-    for (type, member) in _cpp_type_map.keys():
+    for (type, member) in _cpp_callback_map.keys():
       if type not in _cpp_partial_map:
         _cpp_partial_map[type] = set([])
-      _cpp_partial_map[type].add(_cpp_type_map[(type, member)])
+      _cpp_partial_map[type].add(_cpp_callback_map[(type, member)])
+
+    for (type, member) in _cpp_overloaded_callback_map.keys():
+      if type not in _cpp_partial_map:
+        _cpp_partial_map[type] = set([])
+      _cpp_partial_map[type].add(_cpp_overloaded_callback_map[(type, member)])
 
   if interface_name in _cpp_partial_map:
     return _cpp_partial_map[interface_name]
   else:
     return set([])
 
-def _GetCPPTypeName(interface_name, callback_name):
+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_type_map:
-    cpp_type_name = _cpp_type_map[cpp_tuple]
+  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
 
 class DartiumBackend(HtmlDartGenerator):
   """Generates Dart implementation for one DOM IDL interface."""
 
   def __init__(self, interface, cpp_library_emitter, options):
     super(DartiumBackend, self).__init__(interface, options)
 
@@ skipping 12 matching lines @@
     return False
 
   def CustomJSMembers(self):
     return {}
 
   def GenerateCallback(self, info):
     if IsPureInterface(self._interface.id) or IsCustomType(self._interface.id):
       return
 
     cpp_impl_includes = set(['"' + partial + '.h"'
-                             for partial in _GetCPPPartialNames(self._interface.id)])
+                             for partial in _GetCPPPartialNames(self._interface)])
     cpp_header_handlers_emitter = emitter.Emitter()
     cpp_impl_handlers_emitter = emitter.Emitter()
     class_name = 'Dart%s' % self._interface.id
     for operation in self._interface.operations:
       parameters = []
       arguments = []
       conversion_includes = []
       for argument in operation.arguments:
         argument_type_info = self._TypeInfo(argument.type.id)
         parameters.append('%s %s' % (argument_type_info.parameter_type(),
@@ skipping 69 matching lines @@
           self._renamer.GetLibraryName(self._interface))
       self._cpp_impl_emitter = self._cpp_library_emitter.CreateSourceEmitter(self._interface.id)
     else:
       self._cpp_header_emitter = emitter.Emitter()
       self._cpp_impl_emitter = emitter.Emitter()
 
     self._interface_type_info = self._TypeInfo(self._interface.id)
     self._members_emitter = members_emitter
     self._cpp_declarations_emitter = emitter.Emitter()
     self._cpp_impl_includes = set(['"' + partial + '.h"'
-                                   for partial in _GetCPPPartialNames(self._interface.id)])
+                                   for partial in _GetCPPPartialNames(self._interface)])
     self._cpp_definitions_emitter = emitter.Emitter()
     self._cpp_resolver_emitter = emitter.Emitter()
 
     # We need to revisit our treatment of typed arrays, right now
     # it is full of hacks.
     if self._interface.ext_attrs.get('ConstructorTemplate') == 'TypedArray':
       self._cpp_resolver_emitter.Emit(
           '    if (name == "$(INTERFACE_NAME)_constructor_Callback")\n'
           '        return Dart$(INTERFACE_NAME)Internal::constructorCallback;\n',
           INTERFACE_NAME=self._interface.id)
@@ skipping 204 matching lines @@
       webcore_function_name = attr.ext_attrs['ImplementedAs']
     else:
       if attr.id == 'operator':
         webcore_function_name = '_operator'
       elif attr.id == 'target' and attr.type.id == 'SVGAnimatedString':
         webcore_function_name = 'svgTarget'
       elif attr.id == 'CSS':
         webcore_function_name = 'css'
       else:
         webcore_function_name = self._ToWebKitName(attr.id)
-      if attr.type.id.startswith('SVGAnimated'):
-        webcore_function_name += 'Animated'
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     self._GenerateNativeCallback(
         cpp_callback_name,
         True,
         function_expression,
         attr,
         [],
         attr.type.id,
         attr.type.nullable,
         'GetterRaisesException' in attr.ext_attrs or 'RaisesException' in attr.ext_attrs)
 
   def _AddSetter(self, attr, html_name):
     type_info = self._TypeInfo(attr.type.id)
     dart_declaration = 'void set %s(%s value)' % (html_name, self._DartType(attr.type.id))
     is_custom = set(['Custom', 'CustomSetter', 'V8CustomSetter']) & set(attr.ext_attrs)
     cpp_callback_name = self._GenerateNativeBinding(attr.id, 2,
         dart_declaration, 'Setter', is_custom)
     if is_custom:
       return
 
     if 'Reflect' in attr.ext_attrs:
       webcore_function_name = self._TypeInfo(attr.type.id).webcore_setter_name()
     else:
       webcore_function_name = re.sub(r'^(xml(?=[A-Z])|\w)',
                                      lambda s: s.group(1).upper(),
                                      attr.id)
       webcore_function_name = 'set%s' % webcore_function_name
-      if attr.type.id.startswith('SVGAnimated'):
-        webcore_function_name += 'Animated'
 
     function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, attr)
     self._GenerateNativeCallback(
         cpp_callback_name,
         True,
         function_expression,
         attr,
         [attr],
         'void',
         False,
@@ skipping 150 matching lines @@
         operations,
         dart_declaration,
         GenerateCall,
         self._IsArgumentOptionalInWebCore)
 
   def SecondaryContext(self, interface):
     pass
 
   def _GenerateOperationNativeCallback(self, operation, arguments, cpp_callback_name):
     webcore_function_name = operation.ext_attrs.get('ImplementedAs', operation.id)
-    function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, operation)
+    function_expression = self._GenerateWebCoreFunctionExpression(webcore_function_name, operation, cpp_callback_name)
     self._GenerateNativeCallback(
         cpp_callback_name,
         not operation.is_static,
         function_expression,
         operation,
         arguments,
         operation.type.id,
         operation.type.nullable,
         'RaisesException' in operation.ext_attrs)
 
   def _GenerateNativeCallback(self,
       callback_name,
       needs_receiver,
       function_expression,
       node,
       arguments,
       return_type,
       return_type_is_nullable,
       raises_dom_exception):
+
     ext_attrs = node.ext_attrs
 
     cpp_arguments = []
     runtime_check = None
     raises_exceptions = raises_dom_exception or arguments
 
     # TODO(antonm): unify with ScriptState below.
     requires_stack_info = (ext_attrs.get('CallWith') == 'ScriptArguments|ScriptState' or
-                           ext_attrs.get('ConstructorCallWith') == 'ScriptArguments|ScriptState')
+                           ext_attrs.get('ConstructorCallWith') == 'ScriptArguments|ScriptState' or
+                           ext_attrs.get('CallWith') == 'ScriptArguments&ScriptState' or
+                           ext_attrs.get('ConstructorCallWith') == 'ScriptArguments&ScriptState')
     if requires_stack_info:
       raises_exceptions = True
       cpp_arguments = ['&state', 'scriptArguments.release()']
       # WebKit uses scriptArguments to reconstruct last argument, so
       # it's not needed and should be just removed.
       arguments = arguments[:-1]
 
     # TODO(antonm): unify with ScriptState below.
     requires_script_arguments = (ext_attrs.get('CallWith') == 'ScriptArguments' or
                                  ext_attrs.get('ConstructorCallWith') == 'ScriptArguments')
@@ skipping 154 matching lines @@
 
     # Emit arguments.
     start_index = 1 if needs_receiver else 0
     for i, argument in enumerate(arguments):
       type_info = self._TypeInfo(argument.type.id)
       self._cpp_impl_includes |= set(type_info.conversion_includes())
       argument_expression_template, type, cls, function = \
           type_info.to_native_info(argument, self._interface.id)
 
       def AllowsNull():
-        assert argument.ext_attrs.get('TreatNullAs', 'NullString') == 'NullString'
+        # TODO(vsm): HTMLSelectElement's indexed setter treats a null as a remove.
+        # We need to handle that.
+        # assert argument.ext_attrs.get('TreatNullAs', 'NullString') == 'NullString'
         if argument.ext_attrs.get('TreatNullAs') == 'NullString':
           return True
 
         if argument.type.nullable:
           return True
 
         if isinstance(argument, IDLAttribute):
           return (argument.type.id == 'DOMString') and \
               ('Reflect' in argument.ext_attrs)
 
@@ skipping 31 matching lines @@
       self._cpp_impl_includes.add('"%s.h"' % cls)
       cpp_arguments.append(argument_expression_template % argument_name)
 
     body_emitter.Emit('\n')
 
     if 'NeedsUserGestureCheck' in ext_attrs:
       cpp_arguments.append('DartUtilities::processingUserGesture')
 
     invocation_emitter = body_emitter
     if raises_dom_exception:
-      cpp_arguments.append('ec')
+      cpp_arguments.append('es')
       invocation_emitter = body_emitter.Emit(
-        '        ExceptionCode ec = 0;\n'
+        # TODO(vsm): The move from ExceptionCode to ExceptionState adds
+        # a V8 dependency.  Constructing with a NULL V8 isolate....
+        '        ExceptionState es(0);\n'
         '$!INVOCATION'
-        '        if (UNLIKELY(ec)) {\n'
-        '            exception = DartDOMWrapper::exceptionCodeToDartException(ec);\n'
+        '        if (es.hadException()) {\n'
+        '            exception = DartDOMWrapper::exceptionCodeToDartException(es);\n'
         '            goto fail;\n'
         '        }\n')
 
 
     if needs_receiver:
       interface_name = self._interface_type_info.native_type()
-      cpp_type_name = _GetCPPTypeName(interface_name,
-                                      node.id)
-      # Hack to determine if this came from the _cpp_type_map.
+      # Hack to determine if this came from the _cpp_callback_map.
       # In this case, the getter is mapped to a static method.
       if (not function_expression.startswith('receiver->') and
           not function_expression.startswith(interface_name + '::')):
-        if 'childNodes' in callback_name:
-          print function_expression
-          print interface_name
-          raise 'hell'
-        if interface_name == 'DOMWindow' or interface_name == 'Navigator':
+        if interface_name == 'DOMWindow' or interface_name == 'Navigator' or interface_name == 'WorkerGlobalScope':
           cpp_arguments.insert(0, 'receiver')
         else:
           cpp_arguments.append('receiver')
 
     function_call = '%s(%s)' % (function_expression, ', '.join(cpp_arguments))
     if return_type == 'void':
       invocation_emitter.Emit(
         '        $FUNCTION_CALL;\n',
         FUNCTION_CALL=function_call)
     else:
@@ skipping 66 matching lines @@
     svg_exceptions = ['class', 'id', 'onabort', 'onclick', 'onerror', 'onload',
                       'onmousedown', 'onmousemove', 'onmouseout', 'onmouseover',
                       'onmouseup', 'onresize', 'onscroll', 'onunload']
     if self._interface.id.startswith('SVG') and not attr.id in svg_exceptions:
       namespace = 'SVGNames'
     self._cpp_impl_includes.add('"%s.h"' % namespace)
 
     attribute_name = attr.ext_attrs['Reflect'] or attr.id.lower()
     return 'WebCore::%s::%sAttr' % (namespace, attribute_name)
 
-  def _GenerateWebCoreFunctionExpression(self, function_name, idl_node):
+  def _GenerateWebCoreFunctionExpression(self, function_name, idl_node, cpp_callback_name=None):
     if 'ImplementedBy' in idl_node.ext_attrs:
       return '%s::%s' % (idl_node.ext_attrs['ImplementedBy'], function_name)
+    cpp_type_name = self._interface_type_info.native_type()
+    impl_type_name = _GetCPPTypeName(cpp_type_name, function_name, cpp_callback_name)
     if idl_node.is_static:
-      return '%s::%s' % (self._interface_type_info.native_type(), function_name)
-    interface_name = self._interface_type_info.idl_type()
-    cpp_type_name = _GetCPPTypeName(interface_name, function_name)
-    if cpp_type_name == interface_name:
+      return '%s::%s' % (impl_type_name, function_name)
+    if cpp_type_name == impl_type_name:
       return '%s%s' % (self._interface_type_info.receiver(), function_name)
     else:
-      return '%s::%s' % (cpp_type_name, function_name)
+      return '%s::%s' % (impl_type_name, function_name)
 
   def _IsArgumentOptionalInWebCore(self, operation, argument):
     if not IsOptional(argument):
       return False
     if 'Callback' in argument.ext_attrs:
       return False
     if operation.id in ['addEventListener', 'removeEventListener'] and argument.id == 'useCapture':
       return False
     if 'ForceOptional' in argument.ext_attrs:
       return False
@@ skipping 62 matching lines @@
             '    if (Dart_NativeFunction func = $CLASS_NAME::resolver(name, argumentCount))\n'
             '        return func;\n',
             CLASS_NAME=os.path.splitext(os.path.basename(path))[0])
 
 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')