1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
|
# Copyright 2017 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# 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([
'third_party/blink/renderer/bindings/core/v8/generated_code_helper.h',
'third_party/blink/renderer/bindings/core/v8/v8_html_document.h',
'third_party/blink/renderer/bindings/core/v8/v8_initializer.h',
'third_party/blink/renderer/bindings/core/v8/v8_window.h',
'third_party/blink/renderer/platform/bindings/v8_object_constructor.h',
'v8/include/v8.h'
])
TEMPLATE_FILE = 'external_reference_table.cc.tmpl'
SNAPSHOTTED_INTERFACES = frozenset([
'Window',
'EventTarget',
'HTMLDocument',
'Document',
'Node',
])
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument(
'--idl-files-list',
type=str,
required=True,
help='file listing IDL files')
parser.add_argument(
'--output', type=str, required=True, help='output file path')
parser.add_argument(
'--info-dir',
type=str,
required=True,
help='directory contains component info')
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()
# This class creates a Jinja template context about an interface.
class InterfaceTemplateContextBuilder(object):
def __init__(self, opts, info_provider):
self._opts = opts
self._info_provider = info_provider
def create_interface_context(self, interface, component, interfaces):
'''Creates a Jinja context which is based on an interface.'''
assert component in ['core', 'modules']
name = '%s%s' % (v8_utilities.cpp_name(interface),
'Partial' if interface.is_partial else '')
# Constructors
has_constructor_callback = False
if not interface.is_partial:
constructors = any(constructor.name == 'Constructor'
for constructor in interface.constructors)
custom_constructors = interface.custom_constructors
html_constructor = 'HTMLConstructor' in interface.extended_attributes
has_constructor_callback = constructors or custom_constructors or html_constructor
attributes = []
methods = []
has_cross_origin_indexed_getter = False
has_cross_origin_named_enum = False
has_cross_origin_named_getter = False
has_cross_origin_named_setter = False
has_security_check = False
indexed_property_getter = None
is_global = False
named_property_getter = None
component_info = self._info_provider.component_info
if interface.name in SNAPSHOTTED_INTERFACES:
attributes = [
v8_attributes.attribute_context(interface, attribute,
interfaces, component_info)
for attribute in interface.attributes
]
methods = v8_interface.methods_context(interface,
component_info)['methods']
is_global = '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'])
if not interface.is_partial:
has_security_check = (
'CheckSecurity' in interface.extended_attributes
and interface.name != 'EventTarget')
has_cross_origin_named_getter = (
any(method['is_cross_origin'] for method in methods)
or any(attribute['has_cross_origin_getter']
for attribute in attributes))
has_cross_origin_named_setter = any(
attribute['has_cross_origin_setter']
for attribute in attributes)
has_cross_origin_indexed_getter = (
indexed_property_getter
and indexed_property_getter['is_cross_origin'])
has_cross_origin_named_enum = has_cross_origin_named_getter \
or has_cross_origin_named_setter
if (named_property_getter
and named_property_getter['is_cross_origin']):
has_cross_origin_named_getter = True
return {
'attributes':
attributes,
'component':
component,
'has_constructor_callback':
has_constructor_callback,
'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),
'internal_namespace':
v8_interface.internal_namespace(interface),
'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_class':
v8_utilities.v8_class_name_or_partial(interface),
}
# This class applies a Jinja template and creates a .cpp file for the external reference table.
class ExternalReferenceTableGenerator(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'])
# Creates a Jinja context from an IDL file.
def process_idl_file(self, idl_filename):
definitions = self._reader.read_idl_definitions(idl_filename)
for component in definitions:
target_definitions = definitions[component]
interfaces = target_definitions.interfaces
first_name = target_definitions.first_name
if first_name in interfaces.keys():
interface = interfaces[first_name]
self._process_interface(interface, component, interfaces)
# Creates a Jinja context from an interface. Some interfaces are not used
# in V8 context snapshot, so we can skip them.
def _process_interface(self, interface, component, interfaces):
def has_impl(interface):
component_info = self._info_provider.component_info
runtime_features = component_info['runtime_enabled_features']
# Non legacy callback interface does not provide V8 callbacks.
if interface.is_callback:
return len(interface.constants) > 0
if v8_utilities.runtime_enabled_feature_name(
interface, runtime_features):
return False
if 'Exposed' not in interface.extended_attributes:
return True
return any(
exposure.exposed == 'Window'
and exposure.runtime_enabled is None
for exposure in interface.extended_attributes['Exposed'])
if not has_impl(interface):
return
context_builder = InterfaceTemplateContextBuilder(
self._opts, self._info_provider)
context = context_builder.create_interface_context(
interface, component, interfaces)
name = '%s%s' % (interface.name,
'Partial' if interface.is_partial else '')
self._interface_contexts[name] = context
# Do not include unnecessary header files.
if not context['attributes'] and not context['named_property_setter']:
return
include_file = 'third_party/blink/renderer/bindings/%s/v8/%s.h' % (
component, utilities.to_snake_case(context['v8_class']))
self._include_files.add(include_file)
# Gathers all interface-dependent information and returns as a Jinja template context.
def _create_template_context(self):
interfaces = []
for name in sorted(self._interface_contexts):
interfaces.append(self._interface_contexts[name])
header_path = 'third_party/blink/renderer/bindings/modules/v8/v8_context_snapshot_external_references.h'
include_files = list(self._include_files)
return {
'class': 'V8ContextSnapshotExternalReferences',
'interfaces': interfaces,
'include_files': sorted(include_files),
'this_include_header_path': header_path,
'code_generator': os.path.basename(__file__),
'jinja_template_filename': TEMPLATE_FILE
}
# Applies a Jinja template on a context and generates a C++ code.
def generate(self):
jinja_env = initialize_jinja_env(self._opts.cache_dir)
context = self._create_template_context()
cpp_template = jinja_env.get_template(TEMPLATE_FILE)
cpp_text = cpp_template.render(context)
return cpp_text
def main():
opts, _ = parse_args()
# TODO(peria): get rid of |info_provider|
info_provider = create_component_info_provider(opts.info_dir,
opts.target_component)
generator = ExternalReferenceTableGenerator(opts, info_provider)
idl_files = utilities.read_idl_files_list_from_file(opts.idl_files_list)
for idl_file in idl_files:
generator.process_idl_file(idl_file)
output_code = generator.generate()
output_path = opts.output
write_file(output_code, output_path)
if __name__ == '__main__':
main()
|