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 18 matching lines @@
 """Generate Blink V8 bindings (.h and .cpp files).
 
 Input: An object of class IdlDefinitions, containing an IDL interface X
 Output: V8X.h and V8X.cpp
 """
 
 import os
 import posixpath
 import re
 import sys
+import idl_definitions
 
 # jinja2 is in chromium's third_party directory.
 module_path, module_name = os.path.split(__file__)
 third_party = os.path.join(module_path, os.pardir, os.pardir, os.pardir, os.pardir)
 sys.path.append(third_party)
 import jinja2
 
 
 CALLBACK_INTERFACE_CPP_INCLUDES = set([
     'core/dom/ScriptExecutionContext.h',
     'bindings/v8/V8Binding.h',
     'bindings/v8/V8Callback.h',
     'wtf/Assertions.h',
 ])
 
 
 CALLBACK_INTERFACE_H_INCLUDES = set([
     'bindings/v8/ActiveDOMCallback.h',
     'bindings/v8/DOMWrapperWorld.h',
     'bindings/v8/ScopedPersistent.h',
 ])
 
 
 CPP_TYPE_SPECIAL_CONVERSION_RULES = {
+    'any': 'ScriptValue',
     'float': 'float',
     'double': 'double',
     'long long': 'long long',
     'unsigned long long': 'unsigned long long',
     'long': 'int',
     'short': 'int',
     'byte': 'int',
     'boolean': 'bool',
     'DOMString': 'const String&',
 }
@@ skipping 37 matching lines @@
         return 'Vector<%s >' % cpp_type(sequence_type(data_type), 'RefPtr')
     if pointer_type == 'raw':
         return data_type + '*'
     if pointer_type == 'RefPtr':
         return 'RefPtr<%s>' % data_type
     return ''
 
 
 def cpp_value_to_js_value(data_type, cpp_value, isolate, creation_context=''):
     """Returns a expression that represent JS value corresponding to a C++ value."""
+    if data_type == 'any':
+        return '%s.v8Value()' % cpp_value
     if data_type == 'boolean':
         return 'v8Boolean(%s, %s)' % (cpp_value, isolate)
     if data_type in ['long long', 'unsigned long long', 'DOMTimeStamp']:
         # long long and unsigned long long are not representable in ECMAScript.
         return 'v8::Number::New(static_cast<double>(%s))' % cpp_value
     if primitive_type(data_type):
         if data_type not in ['float', 'double']:
             raise Exception('unexpected data_type %s' % data_type)
         return 'v8::Number::New(%s)' % cpp_value
     if data_type == 'DOMString':
@@ skipping 11 matching lines @@
         if operator in conditional:
             conditions = set(conditional.split(operator))
             operator_separator = ' %s%s ' % (operator, operator)
             return operator_separator.join(['ENABLE(%s)' % expression for expression in sorted(conditions)])
     return 'ENABLE(%s)' % conditional
 
 
 def includes_for_type(data_type):
     if primitive_type(data_type) or data_type == 'DOMString':
         return set()
+    if data_type == 'any':
+        return set(['bindings/v8/ScriptValue.h'])
     if sequence_type(data_type):
         return includes_for_type(sequence_type(data_type))
     return set(['V8%s.h' % data_type])
 
 
 def includes_for_operation(operation):
     includes = includes_for_type(operation.data_type)
     for parameter in operation.arguments:
         includes |= includes_for_type(parameter.data_type)
     return includes
@@ skipping 62 matching lines @@
         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'
         template_contents = {
             'conditional_string': generate_conditional_string(self.interface),
         }
         if self.interface.is_callback:
             template_contents.update(self.generate_callback_interface())
-            header_file_text = apply_template('templates/callback.h', template_contents)
-            cpp_file_text = apply_template('templates/callback.cpp', template_contents)
+            header_file_text = apply_template('templates/callback.h.tmpl', template_contents)
+            cpp_file_text = apply_template('templates/callback.cpp.tmpl', template_contents)
         else:
             # FIXME: Implement.
             header_file_text = ''
             cpp_file_text = ''
         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 14 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)
 
+            # FIXME: The CallWith extended attribute should be parsed into a list of values
+            call_with_this_value = 'ThisValue' in operation.extended_attributes.get('CallWith', '').split('|')

[haraken, 2013/08/05 10:52:41]

Could you implement a helper method so that we can write this as follows?

  call_with_this_value = 'ThisValue' in
values_of_extended_attribute(operation.extended_attributes, 'CallWith')

[alancutter (OOO until 2018), 2013/08/06 04:47:13]

Done.

+            this_value_argument = generate_argument(idl_definitions.IdlArgument('thisValue', 'any'))
+            declaration_arguments = operation.arguments
+            if call_with_this_value:
+                declaration_arguments = [idl_definitions.IdlArgument('thisValue', 'any')] + declaration_arguments

[haraken, 2013/08/05 10:52:41]

Can't you write this as follows?

  operation.arguments += [idl_definitions.IdlArgument('thisValue', 'any')]

+
             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]
             method = {
+                'call_with_this_value': call_with_this_value,
+                'this_value_argument': this_value_argument,
                 'return_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': ', '.join([argument_declaration(argument) for argument in declaration_arguments]),
                 '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