Unify processing of the cases when argument is declared optional in IDLs and is not optional in Web…

lib/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
@@ skipping 531 matching lines @@
       info: An OperationInfo object.
     """
 
     operation = info.operations[0]
 
     if 'CheckSecurityForNode' in operation.ext_attrs:
       # FIXME: exclude from interface as well.
       return
 
     is_custom = 'Custom' in operation.ext_attrs
-    has_optional_arguments = any(_IsArgumentOptionalInWebCore(argument) for argument in operation.arguments)
+    has_optional_arguments = any(self._IsArgumentOptionalInWebCore(operation, argument) for argument in operation.arguments)
     needs_dispatcher = not is_custom and (len(info.operations) > 1 or has_optional_arguments)
 
     if not needs_dispatcher:
       type_renamer = self._DartType
       default_value = 'null'
     else:
       type_renamer = lambda x: 'Dynamic'
       default_value = '_null'
 
     dart_declaration = '%s%s %s(%s)' % (
@@ skipping 54 matching lines @@
         argument = operation.arguments[i]
         argument_name = argument_names[i]
         checks[i] = '(%s is %s || %s === null)' % (
             argument_name, self._DartType(argument.type.id), argument_name)
       GenerateCall(operation, argument_count, checks)
 
     # TODO: Optimize the dispatch to avoid repeated checks.
     if len(operations) > 1:
       for operation in operations:
         for position, argument in enumerate(operation.arguments):
-          if _IsArgumentOptionalInWebCore(argument):
+          if self._IsArgumentOptionalInWebCore(operation, argument):
             GenerateChecksAndCall(operation, position)
         GenerateChecksAndCall(operation, len(operation.arguments))
       body.Emit('    throw "Incorrect number or type of arguments";\n');
     else:
       operation = operations[0]
       for position, argument in list(enumerate(operation.arguments))[::-1]:
-        if _IsArgumentOptionalInWebCore(argument):
+        if self._IsArgumentOptionalInWebCore(operation, argument):
           check = '%s === _null' % argument_names[position]
           GenerateCall(operation, position, [check])
       GenerateCall(operation, len(operation.arguments), [])
 
   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)
@@ skipping 153 matching lines @@
           INDEX=len(arguments) + 1)
 
     # 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.to_native_includes())
       cpp_arguments.append(type_info.emit_to_native(
           body_emitter,
           argument,
+          IsOptional(argument) and not self._IsArgumentOptionalInWebCore(node, argument),
           # TODO(antonm): all IDs should be renamed when database is generated.
           # That will allow to get rid of argument_name argument altogether.
           DartDomNameOfAttribute(argument),
           'Dart_GetNativeArgument(args, %i)' % (start_index + i),
           self._interface.id))
 
     body_emitter.Emit('\n')
 
-    # FIXME: rework in IDLs.
-    if node.id in ['addEventListener', 'removeEventListener']:
-      # addEventListener's and removeEventListener's last argument is marked
-      # as optional in idl, but is not optional in webcore implementation.
-      if len(arguments) == 2:
-        cpp_arguments.append('false')
-
-    if self._interface.id == 'CSSStyleDeclaration' and node.id == 'setProperty':
-      # CSSStyleDeclaration.setProperty priority parameter is optional in Dart
-      # idl, but is not optional in webcore implementation.
-      if len(arguments) == 2:
-        cpp_arguments.append('String()')
-
     if 'NeedsUserGestureCheck' in ext_attrs:
       cpp_arguments.append('DartUtilities::processingUserGesture');
 
     invocation_emitter = body_emitter
     if raises_dom_exception:
       cpp_arguments.append('ec')
       invocation_emitter = body_emitter.Emit(
         '        ExceptionCode ec = 0;\n'
         '$!INVOCATION'
         '        if (UNLIKELY(ec)) {\n'
@@ skipping 58 matching lines @@
   def _GenerateWebCoreFunctionExpression(self, function_name, idl_node):
     if 'ImplementedBy' in idl_node.ext_attrs:
       return '%s::%s' % (idl_node.ext_attrs['ImplementedBy'], function_name)
     if idl_node.is_static:
       return '%s::%s' % (self._interface_type_info.idl_type(), function_name)
     return '%s%s' % (self._interface_type_info.receiver(), function_name)
 
   def _TypeInfo(self, type_name):
     return self._system._type_registry.TypeInfo(type_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
+    # Another option would be to adjust in IDLs, but let's keep it here for now
+    # as it's a single instance.
+    if self._interface.id == 'CSSStyleDeclaration' and operation.id == 'setProperty' and argument.id == 'priority':
+      return False
+    return True
+
 
 def _GenerateCPPIncludes(includes):
   return ''.join(['#include %s\n' % include for include in sorted(includes)])
 
 def _FindInHierarchy(database, interface, test):
   if test(interface):
     return interface
   for parent in interface.parents:
     parent_name = parent.type.id
     if not database.HasInterface(parent.type.id):
       continue
     parent_interface = database.GetInterface(parent.type.id)
     parent_interface = _FindInHierarchy(database, parent_interface, test)
     if parent_interface:
       return parent_interface
 
-def _IsArgumentOptionalInWebCore(argument):
-  return IsOptional(argument) and not 'Callback' in argument.ext_attrs
-
 def _ToWebKitName(name):
   name = name[0].lower() + name[1:]
   name = re.sub(r'^(hTML|uRL|jS|xML|xSLT)', lambda s: s.group(1).lower(),
                 name)
   return re.sub(r'^(create|exclusive)', lambda s: 'is' + s.group(1).capitalize(),
                 name)