Roll 50: Copied IDLs, PYTHON scripts from WebKit removed deleted files in WebCore

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 61 matching lines @@
 
 from idl_definitions import Visitor
 import idl_types
 from idl_types import IdlType
 import v8_callback_interface
 import v8_dictionary
 from v8_globals import includes, interfaces
 import v8_interface
 import v8_types
 import v8_union
-from v8_utilities import capitalize, cpp_name, conditional_string, v8_class_name
+from v8_utilities import capitalize, cpp_name, v8_class_name
 from utilities import KNOWN_COMPONENTS, idl_filename_to_component, is_valid_component_dependency, is_testing_target
 
 
+def normalize_and_sort_includes(include_paths):
+    normalized_include_paths = []
+    for include_path in include_paths:
+        match = re.search(r'/gen/blink/(.*)$', posixpath.abspath(include_path))
+        if match:
+            include_path = match.group(1)
+        normalized_include_paths.append(include_path)
+    return sorted(normalized_include_paths)
+
+
 def render_template(include_paths, header_template, cpp_template,
                     template_context, component=None):
     template_context['code_generator'] = module_pyname
 
     # Add includes for any dependencies
-    template_context['header_includes'] = sorted(
+    template_context['header_includes'] = normalize_and_sort_includes(
         template_context['header_includes'])
 
     for include_path in include_paths:
         if component:
             dependency = idl_filename_to_component(include_path)
             assert is_valid_component_dependency(component, dependency)
         includes.add(include_path)
 
-    template_context['cpp_includes'] = sorted(includes)
+    template_context['cpp_includes'] = normalize_and_sort_includes(includes)
 
     header_text = header_template.render(template_context)
     cpp_text = cpp_template.render(template_context)
     return header_text, cpp_text
 
 
 def set_global_type_info(info_provider):
     interfaces_info = info_provider.interfaces_info
     idl_types.set_ancestors(interfaces_info['ancestors'])
     IdlType.set_callback_interfaces(interfaces_info['callback_interfaces'])
@@ skipping 127 matching lines @@
             header_template_filename = 'partial_interface.h'
             cpp_template_filename = 'partial_interface.cpp'
             interface_name += 'Partial'
             assert component == 'core'
             component = 'modules'
             include_paths = interface_info.get('dependencies_other_component_include_paths')
         else:
             header_template_filename = 'interface.h'
             cpp_template_filename = 'interface.cpp'
             interface_context = v8_interface.interface_context
-        header_template = self.jinja_env.get_template(header_template_filename)
-        cpp_template = self.jinja_env.get_template(cpp_template_filename)
 
         template_context = interface_context(interface)
+        includes.update(interface_info.get('cpp_includes', {}).get(component, set()))
         if not interface.is_partial and not is_testing_target(full_path):
             template_context['header_includes'].add(self.info_provider.include_path_for_export)
             template_context['exported'] = self.info_provider.specifier_for_export
         # Add the include for interface itself
         if IdlType(interface_name).is_typed_array:
             template_context['header_includes'].add('core/dom/DOMTypedArray.h')
         elif interface_info['include_path']:
             template_context['header_includes'].add(interface_info['include_path'])
+
+        header_template = self.jinja_env.get_template(header_template_filename)
+        cpp_template = self.jinja_env.get_template(cpp_template_filename)
         header_text, cpp_text = render_template(
             include_paths, header_template, cpp_template, template_context,
             component)
         header_path, cpp_path = self.output_paths(interface_name)
         return (
             (header_path, header_text),
             (cpp_path, cpp_text),
         )
 
     def generate_dictionary_code(self, definitions, dictionary_name,
@@ skipping 93 matching lines @@
 
         # Add UnionTypesCore.h as a dependency when we generate modules union types
         # because we only generate union type containers which are used by both
         # core and modules in UnionTypesCore.h.
         # FIXME: This is an ad hoc workaround and we need a general way to
         # handle core <-> modules dependency.
         if self.target_component == 'modules':
             additional_header_includes.append(
                 'bindings/core/v8/UnionTypesCore.h')
 
-        template_context['header_includes'] = sorted(
+        template_context['header_includes'] = normalize_and_sort_includes(
             template_context['header_includes'] + additional_header_includes)
 
         header_text = header_template.render(template_context)
         cpp_text = cpp_template.render(template_context)
         header_path = posixpath.join(self.output_dir,
                                      'UnionTypes%s.h' % capitalized_component)
         cpp_path = posixpath.join(self.output_dir,
                                   'UnionTypes%s.cpp' % capitalized_component)
         return (
             (header_path, header_text),
             (cpp_path, cpp_text),
         )
 
 
 def initialize_jinja_env(cache_dir):
     jinja_env = jinja2.Environment(
         loader=jinja2.FileSystemLoader(templates_dir),
         # Bytecode cache is not concurrency-safe unless pre-cached:
         # if pre-cached this is read-only, but writing creates a race condition.
         bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir),
         keep_trailing_newline=True,  # newline-terminate generated files
         lstrip_blocks=True,  # so can indent control flow tags
         trim_blocks=True)
     jinja_env.filters.update({
         'blink_capitalize': capitalize,
-        'conditional': conditional_if_endif,
         'exposed': exposed_if,
         'runtime_enabled': runtime_enabled_if,
         })
     return jinja_env
 
 
 def generate_indented_conditional(code, conditional):
     # Indent if statement to level of original code
     indent = re.match(' *', code).group(0)
     return ('%sif (%s) {\n' % (indent, conditional) +
             '    %s\n' % '\n    '.join(code.splitlines()) +
             '%s}\n' % indent)
 
 
-# [Conditional]
-def conditional_if_endif(code, conditional_string):
-    # Jinja2 filter to generate if/endif directive blocks
-    if not conditional_string:
-        return code
-    return ('#if %s\n' % conditional_string +
-            code +
-            '#endif // %s\n' % conditional_string)
-
-
 # [Exposed]
 def exposed_if(code, exposed_test):
     if not exposed_test:
         return code
-    return generate_indented_conditional(code, 'context && (%s)' % exposed_test)
+    return generate_indented_conditional(code, 'executionContext && (%s)' % exposed_test)
 
 
 # [RuntimeEnabled]
 def runtime_enabled_if(code, runtime_enabled_function_name):
     if not runtime_enabled_function_name:
         return code
     return generate_indented_conditional(code, '%s()' % runtime_enabled_function_name)
 
 
 ################################################################################
@@ skipping 17 matching lines @@
 
     # Create a dummy file as output for the build system,
     # since filenames of individual cache files are unpredictable and opaque
     # (they are hashes of the template path, which varies based on environment)
     with open(dummy_filename, 'w') as dummy_file:
         pass  # |open| creates or touches the file
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))