IDL: make optional arguments (without default) explicit sometimes

Source/bindings/scripts/v8_methods.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 49 matching lines @@
         # generate_argument() macro in Source/bindings/templates/methods.cpp.
         idl_type.is_callback_interface or
         base_type == 'SerializedScriptValue' or
         (argument.is_variadic and idl_type.is_wrapper_type) or
         # String and enumeration arguments converted using one of the
         # TOSTRING_* macros in Source/bindings/v8/V8BindingMacros.h don't
         # use a v8::TryCatch.
         (base_type == 'DOMString' and not argument.is_variadic))
 
 
+def argument_is_explicit_optional(method, index):
+    argument = method.arguments[index]
+    if not(argument.is_optional and
+           not argument.default_value and
+           not 'Default' in argument.extended_attributes):
+        # Argument itself is not optional, or has a default value.
+        return False
+    for following in method.arguments[index + 1:]:
+        if (following.default_value or
+            'Default' in following.extended_attributes):
+            # A following argument has a default value.
+            return True
+    return False
+
+
 def generate_method(interface, method):
     arguments = method.arguments
     extended_attributes = method.extended_attributes
     idl_type = method.idl_type
     is_static = method.is_static
     name = method.name
 
     idl_type.add_includes_for_type()
     this_cpp_value = cpp_value(interface, method, len(arguments))
 
@@ skipping 116 matching lines @@
         'has_type_checking_unrestricted':
             (has_extended_attribute_value(interface, 'TypeChecking', 'Unrestricted') or
              has_extended_attribute_value(method, 'TypeChecking', 'Unrestricted')) and
             idl_type.name in ('Float', 'Double'),
         # Dictionary is special-cased, but arrays and sequences shouldn't be
         'idl_type': not idl_type.array_or_sequence_type and idl_type.base_type,
         'idl_type_object': idl_type,
         'index': index,
         'is_clamp': 'Clamp' in extended_attributes,
         'is_callback_interface': idl_type.is_callback_interface,
+        'is_explicit_optional': argument_is_explicit_optional(method, index),
         'is_nullable': idl_type.is_nullable,
         'is_optional': argument.is_optional,
         'is_variadic_wrapper_type': is_variadic_wrapper_type,
         'vector_type': v8_types.cpp_ptr_type('Vector', 'HeapVector', idl_type.gc_type),
         'is_wrapper_type': idl_type.is_wrapper_type,
         'name': argument.name,
         'v8_set_return_value_for_main_world': v8_set_return_value(interface.name, method, this_cpp_value, for_main_world=True),
         'v8_set_return_value': v8_set_return_value(interface.name, method, this_cpp_value),
         'v8_value_to_local_cpp_value': v8_value_to_local_cpp_value(argument, index),
     }
 
 
 ################################################################################
 # Value handling
 ################################################################################
 
 def cpp_value(interface, method, number_of_arguments):
-    def cpp_argument(argument):
+    def cpp_argument(index):
+        argument = method.arguments[index]
         idl_type = argument.idl_type
         if idl_type.name == 'EventListener':
             if (interface.name == 'EventTarget' and
                 method.name == 'removeEventListener'):
                 # FIXME: remove this special case by moving get() into
                 # EventTarget::removeEventListener
                 return '%s.get()' % argument.name
             return argument.name
         if (idl_type.is_callback_interface or
             idl_type.name in ['NodeFilter', 'XPathNSResolver']):
             # FIXME: remove this special case
             return '%s.release()' % argument.name
+        if argument_is_explicit_optional(method, index):
+            return 'makeOptional({name}, {name}Missing)'.format(
+                name=argument.name)
         return argument.name
 
-    # Truncate omitted optional arguments
-    arguments = method.arguments[:number_of_arguments]
     cpp_arguments = v8_utilities.call_with_arguments(method)
     # Members of IDL partial interface definitions are implemented in C++ as
     # static member functions, which for instance members (non-static members)
     # take *impl as their first argument
     if ('PartialInterfaceImplementedAs' in method.extended_attributes and
         not method.is_static):
         cpp_arguments.append('*impl')
-    cpp_arguments.extend(cpp_argument(argument) for argument in arguments)
+    cpp_arguments.extend(cpp_argument(index)
+                         for index in range(number_of_arguments))
     this_union_arguments = method.idl_type and method.idl_type.union_arguments
     if this_union_arguments:
         cpp_arguments.extend(this_union_arguments)
 
     if 'RaisesException' in method.extended_attributes:
         cpp_arguments.append('exceptionState')
 
     if method.name == 'Constructor':
         base_name = 'create'
     elif method.name == 'NamedConstructor':
@@ skipping 65 matching lines @@
 
 
 def union_arguments(idl_type):
     """Return list of ['result0Enabled', 'result0', 'result1Enabled', ...] for union types, for use in setting return value"""
     return [arg
             for i in range(len(idl_type.member_types))
             for arg in ['result%sEnabled' % i, 'result%s' % i]]
 
 IdlType.union_arguments = property(lambda self: None)
 IdlUnionType.union_arguments = property(union_arguments)