IDL compiler: [ActivityLogging] for methods

Source/bindings/scripts/unstable/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 35 matching lines @@
 
     this_custom_signature = custom_signature(arguments)
     if this_custom_signature:
         signature = name + 'Signature'
     elif is_static:
         signature = 'v8::Local<v8::Signature>()'
     else:
         signature = 'defaultSignature'
 
     contents = {
+        'activity_logging_world_list': v8_utilities.activity_logging_world_list(method, 'Access'),  # [ActivityLogging]

[haraken, 2013/11/05 06:27:37]

What is 'Access'? Shall we rename it to 'Method'?

[Nils Barth (inactive), 2013/11/05 06:40:57]

Agreed we should rename; will do in a followup; please choose a name.

Access is *either*:
* 'Getter&Setter' (for attributes)
* ...or the only ok one for methods

Agreed, it definitely would be clearer to not use 'Access' for methods;
'Access' suggests attributes.
We could just omit it for methods, since only one logging type is allowed,
especially since we now require world suffix so we'd have
(ditto for ForIsolatedWorlds):
Attributes:
AccessForAllWorlds, GetterForAllWorlds, SetterForAllWorlds

Methods:
ForAllWorlds
...as in:
[ActivityLogging=ForAllWorlds] void foo();

Alternatively, we could require an explicit 'Method', as in:
MethodForAllWorlds

So for methods, do you prefer:
1. AccessForAllWorlds
2. ForAllWorlds
3. MethodForAllWorlds
?

[haraken, 2013/11/05 06:51:04]

I'd prefer ForAllWorlds.

BTW, is it possible to use ForAllWorlds for DOM attributes to indicate that we
want to log both getter and setter? If so, ForAllWorlds sounds even better to
me. Otherwise, it might also make sense to use MethodForAllWorlds to make the
meaning clearer.

         'arguments': [generate_argument(interface, method, argument, index)
                       for index, argument in enumerate(arguments)],
         'cpp_method': cpp_method(interface, method, len(arguments)),
         'custom_signature': this_custom_signature,
         'idl_type': method.idl_type,
         'is_static': is_static,
         'name': name,
         'number_of_required_arguments': len([
             argument for argument in arguments
             if not (argument.is_optional or argument.is_variadic)]),
@@ skipping 70 matching lines @@
     if argument.is_variadic:
         return 'V8TRYCATCH_VOID(Vector<{cpp_type}>, {name}, toNativeArguments<{cpp_type}>(info, {index}))'.format(
                 cpp_type=v8_types.cpp_type(idl_type), name=name, index=index)
     if (argument.is_optional and idl_type == 'DOMString' and
         extended_attributes.get('Default') == 'NullString'):
         v8_value = 'argumentOrNull(info, %s)' % index
     else:
         v8_value = 'info[%s]' % index
     return v8_types.v8_value_to_local_cpp_value(
         idl_type, argument.extended_attributes, v8_value, name, index=index)