Add forEach() to CSSVariablesMap

Source/bindings/scripts/code_generator_v8.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 191 matching lines @@
 
 
 def cpp_class_name(interface):
     return interface.extended_attributes.get('ImplementedAs', interface.name)
 
 
 def v8_class_name(interface):
     return v8_type(interface.name)
 
 
+def has_extended_attribute_value(extended_attributes, key, value):
+    return key in extended_attributes and value in extended_attribute_values(extended_attributes, key)
+
+
+def extended_attribute_values(extended_attributes, key):

[haraken, 2013/08/07 00:55:54]

Nit: Do you need this helper? You might be able to inline this method in
has_extended_attribute_value.

[alancutter (OOO until 2018), 2013/08/07 01:12:48]

I think the motivation for making it a separate function was to let other parts
of the code generator grab the list of values easily if they needed it.
Personally I think it's a distinct enough bit of functionality to warrant being
in its own function.

[Nils Barth (inactive), 2013/08/07 01:50:34]

For reference, I suggested these functions;
as Alan says, I think it's useful to have a separate function,
esp. as the exact handling is a bit tricky and bug-prone.

Agreed that in this case we just need "has_extended_attribute_value",
since we're just checking one value, but in more complex cases I
can see it being easier to use the list of values instead of checking each
individually.

In any case, b/c of the many returns, rather than inlining we'd want
a nested function (to avoid deep nesting), so we don't gain much
compactness-wise either. (>.<)

+    if key not in extended_attributes:
+        return None
+    values_string = extended_attributes[key]
+    if not values_string:
+        return []
+    return re.split('[|&]', values_string)
+
+
 class CodeGeneratorV8:
     def __init__(self, definitions, interface_name, output_directory, relative_dir_posix, idl_directories, verbose=False):
         self.idl_definitions = definitions
         self.interface_name = interface_name
         self.idl_directories = idl_directories
         self.output_directory = output_directory
         self.relative_dir_posix = relative_dir_posix
         self.verbose = verbose
         self.interface = None
         self.header_includes = set()
@@ skipping 25 matching lines @@
     {cpp_basename} at every build. This file must not be tried to compile.
 */
 """.format(**locals())
         self.write_header_code(header_basename, contents)
         self.write_cpp_code(cpp_basename, contents)
 
     def write_header_and_cpp(self):
         header_basename = v8_class_name(self.interface) + '.h'
         cpp_basename = v8_class_name(self.interface) + '.cpp'
         if self.interface.is_callback:
-            header_template = 'templates/callback_interface.h'
-            cpp_template = 'templates/callback_interface.cpp'
+            header_template = 'templates/callback_interface.h.tmpl'
+            cpp_template = 'templates/callback_interface.cpp.tmpl'
             template_contents = self.generate_callback_interface()
         else:
-            header_template = 'templates/interface.h'
-            cpp_template = 'templates/interface.cpp'
+            header_template = 'templates/interface.h.tmpl'
+            cpp_template = 'templates/interface.cpp.tmpl'
             template_contents = self.generate_interface()
         template_contents['conditional_string'] = generate_conditional_string(self.interface)
         header_file_text = apply_template(header_template, template_contents)
         cpp_file_text = apply_template(cpp_template, template_contents)
         self.write_header_code(header_basename, header_file_text)
         self.write_cpp_code(cpp_basename, cpp_file_text)
 
     def write_header_code(self, header_basename, header_file_text):
         header_filename = os.path.join(self.output_directory, header_basename)
         with open(header_filename, 'w') as header_file:
@@ skipping 43 matching lines @@
             cpp_to_js_conversion = self.generate_cpp_to_js_conversion(argument.data_type, argument.name, receiver, 'isolate', creation_context='v8::Handle<v8::Object>()')
             return {
                 'name': argument.name,
                 'cpp_to_js_conversion': cpp_to_js_conversion,
             }
 
         def generate_method(operation):
             def argument_declaration(argument):
                 return '%s %s' % (cpp_type(argument.data_type, 'raw'), argument.name)
 
+            call_with_this_handle = has_extended_attribute_value(operation.extended_attributes, 'CallWith', 'ThisValue')
             arguments = []
             custom = 'Custom' in operation.extended_attributes
             if not custom:
                 self.cpp_includes |= includes_for_operation(operation)
                 if operation.data_type != 'boolean':
                     raise Exception("We don't yet support callbacks that return non-boolean values.")
                 arguments = [generate_argument(argument) for argument in operation.arguments]
+            argument_declaration = ', '.join([argument_declaration(argument) for argument in operation.arguments])
+            if call_with_this_handle:
+                argument_declaration = 'ScriptValue thisValue, ' + argument_declaration
             method = {
+                'call_with_this_handle': call_with_this_handle,
                 'return_cpp_type': cpp_type(operation.data_type, 'RefPtr'),
                 'name': operation.name,
                 'arguments': arguments,
-                'argument_declaration': ', '.join([argument_declaration(argument) for argument in operation.arguments]),
+                'argument_declaration': argument_declaration,
                 'handles': ', '.join(['%sHandle' % argument.name for argument in operation.arguments]),
                 'custom': custom,
             }
             return method
 
         methods = [generate_method(operation) for operation in self.interface.operations]
         template_contents = {
             'cpp_class_name': self.interface.name,
             'v8_class_name': v8_class_name(self.interface),
             'cpp_includes': sorted(list(self.cpp_includes)),
             'header_includes': sorted(list(self.header_includes)),
             'methods': methods,
         }
         return template_contents