[Bindings] Create and use V8 context snapshots

third_party/WebKit/Source/bindings/scripts/generate_reference_table.py

+#!/usr/bin/env python

[haraken, 2017/05/20 19:10:02]

Add a copyright.

[peria, 2017/05/30 08:25:44]

Done.

+
+# pylint: disable=relative-import
+
+import argparse
+import os
+import posixpath
+
+from code_generator import initialize_jinja_env
+from idl_reader import IdlReader
+from utilities import create_component_info_provider, write_file
+import utilities
+import v8_attributes
+import v8_interface
+import v8_types
+import v8_utilities
+
+
+INCLUDES = frozenset([
+    'bindings/core/v8/GeneratedCodeHelper.h',
+    'bindings/core/v8/V8HTMLDocument.h',
+    'bindings/core/v8/V8Initializer.h',
+    'bindings/core/v8/V8Window.h',
+    'platform/bindings/DOMWrapperWorld.h',
+    'platform/bindings/V8ObjectConstructor.h',
+    'platform/bindings/V8PerIsolateData.h',
+    'platform/bindings/V8PrivateProperty.h',
+    'v8/include/v8.h'])
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--idl-files-list', type=str, required=True,
+                        help='file listing IDL files')
+    parser.add_argument('--info-dir', type=str, required=True,
+                        help='directory contains component info')
+    parser.add_argument('--output-dir', type=str, required=True,
+                        help='output directory')
+    parser.add_argument('--cache-dir', type=str, required=True,
+                        help='cache directory')
+    parser.add_argument('--target-component', type=str, required=True,
+                        help='target component')
+    return parser.parse_known_args()
+
+
+class InterfaceTemplateContextBuilder(object):
+    # NOTE: This class is equivalent of v8_interface.py
+    def __init__(self, opts, info_provider):
+        self._opts = opts
+        self._info_provider = info_provider
+
+    def create_interface_context(self, interface, interfaces):
+        attributes = [v8_attributes.attribute_context(interface, attribute, interfaces)
+                      for attribute in interface.attributes]
+        methods, _ = v8_interface.methods_context(interface)
+        name = '%s%s' % (v8_utilities.cpp_name(interface), 'Partial' if interface.is_partial else '')
+        is_global = ('PrimaryGlobal' in interface.extended_attributes or
+                     'Global' in interface.extended_attributes)
+
+        named_property_getter = v8_interface.property_getter(interface.named_property_getter, ['name'])
+        indexed_property_getter = v8_interface.property_getter(interface.indexed_property_getter, ['index'])
+
+        has_origin_safe_method_setter = not interface.is_partial and is_global and any(
+            method['is_check_security_for_receiver'] and not method['is_unforgeable']
+            for method in methods)
+        has_cross_origin_named_getter = (
+            any(attribute['has_cross_origin_getter'] for attribute in attributes) or
+            any(method['is_cross_origin'] for method in methods))
+        has_security_check = False
+        has_cross_origin_named_setter = False
+        has_cross_origin_named_enum = False
+        has_cross_origin_named_getter = False
+        has_cross_origin_indexed_getter = False
+
+        if not interface.is_partial:
+            has_security_check = ('CheckSecurity' in interface.extended_attributes and
+                                  interface.name != 'EventTarget')
+            has_cross_origin_named_setter = any(attribute['has_cross_origin_setter'] for attribute in attributes)
+            has_cross_origin_named_enum = has_cross_origin_named_getter or has_cross_origin_named_setter
+            has_cross_origin_named_getter = named_property_getter and named_property_getter['is_cross_origin']
+            has_cross_origin_indexed_getter = indexed_property_getter and indexed_property_getter['is_cross_origin']
+
+        return {
+            'attributes': attributes,
+            'has_origin_safe_method_setter': has_origin_safe_method_setter,
+            'has_cross_origin_named_getter': has_cross_origin_named_getter,
+            'has_cross_origin_named_setter': has_cross_origin_named_setter,
+            'has_cross_origin_named_enumerator': has_cross_origin_named_enum,
+            'has_cross_origin_indexed_getter': has_cross_origin_indexed_getter,
+            'has_security_check': has_security_check,
+            'indexed_property_getter': indexed_property_getter,
+            'indexed_property_setter': v8_interface.property_setter(interface.indexed_property_setter, interface),
+            'indexed_property_deleter': v8_interface.property_deleter(interface.indexed_property_deleter),
+            'is_array_buffer_or_view': interface.idl_type.is_array_buffer_or_view,
+            'is_callback': interface.is_callback,
+            'is_partial': interface.is_partial,
+            'methods': methods,
+            'name': name,
+            'named_constructor': v8_interface.named_constructor_context(interface),
+            'named_property_getter': named_property_getter,
+            'named_property_setter': v8_interface.property_setter(interface.named_property_setter, interface),
+            'named_property_deleter': v8_interface.property_deleter(interface.named_property_deleter),
+            'v8_name': v8_utilities.v8_class_name_or_partial(interface),
+        }
+
+
+class SnapshotGenerator(object):
+    def __init__(self, opts, info_provider):
+        self._opts = opts
+        self._info_provider = info_provider
+        self._reader = IdlReader(
+            info_provider.interfaces_info, opts.cache_dir)
+        self._interface_contexts = {}
+        self._include_files = set(INCLUDES)
+        v8_types.set_component_dirs(info_provider.interfaces_info['component_dirs'])
+
+    def process_idl_file(self, idl_filename):
+        definitions = self._reader.read_idl_definitions(idl_filename)
+        base_name, _ = os.path.splitext(os.path.basename(idl_filename))
+        for component in definitions:
+            target_definitions = definitions[component]
+            interfaces = target_definitions.interfaces
+            if base_name in interfaces.keys():
+                interface = interfaces[base_name]
+                self._process_interface(interface, component, interfaces)
+
+    def _process_interface(self, interface, component, interfaces):
+        def has_impl(interface):
+            # Non legacy callback interface does not provide V8 callbacks.
+            if interface.is_callback:
+                return len(interface.constants) > 0
+            return True
+
+        if not has_impl(interface):
+            return
+
+        context_builder = InterfaceTemplateContextBuilder(self._opts, self._info_provider)
+        context = context_builder.create_interface_context(interface, interfaces)
+        name = '%s%s' % (interface.name, 'Partial' if interface.is_partial else '')
+        self._interface_contexts[name] = context
+        include_file = 'bindings/%s/v8/%s.h' % (component, context['v8_name'])
+        self._include_files.add(include_file)
+
+    def _create_template_context(self):
+        interfaces = []
+        for name in sorted(self._interface_contexts):
+            interfaces.append(self._interface_contexts[name])
+        return {
+            'interfaces': interfaces,
+            'include_files': sorted(list(self._include_files)),
+        }
+
+    def generate(self):
+        jinja_env = initialize_jinja_env(self._opts.cache_dir)
+        context = self._create_template_context()
+        cpp_template = jinja_env.get_template('snapshot.cpp.tmpl')
+        cpp_text = cpp_template.render(context)
+        cpp_path = posixpath.join(self._opts.output_dir, 'V8SnapshotReference.cpp')
+        return (
+            (cpp_path, cpp_text),
+        )
+
+
+def main():
+    opts, _ = parse_args()
+    info_provider = create_component_info_provider(
+        opts.info_dir, opts.target_component)
+    generator = SnapshotGenerator(opts, info_provider)
+
+    idl_files = utilities.read_idl_files_list_from_file(opts.idl_files_list, False)
+    for idl_file in idl_files:
+        generator.process_idl_file(idl_file)
+    outputs = generator.generate()
+    for output_path, output_code in outputs:
+        write_file(output_code, output_path)
+
+
+if __name__ == '__main__':
+    main()