class MakeMediaFeaturesWriter(json5_generator.Writer):
default_metadata = {
'namespace': '',
'export': '',
}
filters = {
'symbol': media_feature_symbol.getMediaFeatureSymbolWithSuffix(''),
'to_macro_style': name_utilities.to_macro_style,
'upper_first_letter': name_utilities.upper_first_letter,
}
def __init__(self, json5_file_path):
super(MakeMediaFeaturesWriter, self).__init__(json5_file_path)
self._outputs = {
('MediaFeatures.h'): self.generate_header,
}
self._template_context = {
'entries': self.json5_file.name_dictionaries,
}
@template_expander.use_jinja('MediaFeatures.h.tmpl', filters=filters)
def generate_header(self):
return self._template_context
if __name__ == '__main__':
json5_generator.Maker(MakeMediaFeaturesWriter).main()
keyword for keyword in self._value_keywords
if keyword['mode'] == mode
]
@gperf.use_jinja_gperf_template(
'core/css/templates/css_value_keywords.cc.tmpl',
['-Q', 'CSSValueStringPool'])
def generate_implementation(self):
keyword_offsets = []
current_offset = 0
for keyword in self._value_keywords:
keyword_offsets.append(current_offset)
current_offset += len(keyword["name"].original) + 1
return {
'value_keywords':
self._value_keywords,
'value_keyword_offsets':
keyword_offsets,
'ua_sheet_mode_values_keywords':
self._value_keywords_with_mode('UASheet'),
'quirks_mode_or_ua_sheet_mode_values_keywords':
self._value_keywords_with_mode('QuirksOrUASheet'),
'gperf_path':
self.gperf_path,
}
if __name__ == "__main__":
json5_generator.Maker(CSSValueKeywordsWriter).main()
filters=filters)
def generate_factory_implementation(self):
return self._template_context
def _interface(self, tag):
if tag['interfaceName']:
return tag['interfaceName']
name = tag['tokenized_name'].to_upper_camel_case()
# FIXME: We shouldn't hard-code HTML here.
if name == 'HTML':
name = 'Html'
return '%s%sElement' % (self.namespace, name)
def _js_interface(self, tag):
if tag['JSInterfaceName']:
return tag['JSInterfaceName']
return self._interface(tag)
def _has_js_interface(self, tag):
return not tag['noConstructor'] and self._js_interface(tag) != (
'%sElement' % self.namespace)
def _interface_header_dir(self, tag):
if tag['interfaceHeaderDir']:
return tag['interfaceHeaderDir']
return 'third_party/blink/renderer/core/' + self.namespace.lower()
if __name__ == "__main__":
json5_generator.Maker(MakeElementFactoryWriter).main()
yield "core/css/css_primitive_value_mappings.h"
elif property_['converter'] == "CSSIdentifierValue":
yield "core/css/css_identifier_value.h"
else:
yield "core/css/css_primitive_value_mappings.h"
yield "core/css/resolver/style_builder_converter.h"
if property_['font']:
yield "core/css/resolver/font_builder.h"
elif property_['svg']:
yield "core/css/css_primitive_value_mappings.h"
yield "core/style/computed_style.h"
yield "core/style/svg_computed_style.h"
else:
yield "core/style/computed_style.h"
if ('style_builder_template_args' in property_ and
property_['style_builder_template_args'].get('modifier_type')
in ['Width', 'Slice', 'Outset']):
yield "core/css/properties/style_building_utils.h"
if property_.get('style_builder_template') in [
'animation', 'background_layer', 'counter', 'mask_layer',
'transition'
]:
yield "core/css/css_value_list.h"
if property_.get('style_builder_template') in ['counter']:
yield "core/css/css_value_pair.h"
yield "core/css/css_custom_ident_value.h"
if __name__ == '__main__':
json5_generator.Maker(CSSPropertiesWriter).main()
output_dir)
self._tags = {}
for entry in self.json5_file.name_dictionaries:
self._tags[entry['name'].original] = entry['name'].original
self._namespace = self.json5_file.metadata['namespace'].strip('"')
basename = self._namespace.lower() + '_element_lookup_trie'
self._outputs = {
(basename + '.h'): self.generate_header,
(basename + '.cc'): self.generate_implementation,
}
@template_expander.use_jinja('templates/element_lookup_trie.h.tmpl')
def generate_header(self):
return {
'input_files': self._input_files,
'namespace': self._namespace,
}
@template_expander.use_jinja('templates/element_lookup_trie.cc.tmpl',
filters=filters)
def generate_implementation(self):
return {
'input_files': self._input_files,
'namespace': self._namespace,
'length_tries': trie_builder.trie_list_by_str_length(self._tags)
}
if __name__ == '__main__':
json5_generator.Maker(ElementLookupTrieWriter).main()
class InternalRuntimeFlagsWriter(make_runtime_features.RuntimeFeatureWriter):
def __init__(self, json5_file_path, output_dir):
super(InternalRuntimeFlagsWriter, self).__init__(json5_file_path, output_dir)
self._outputs = {
'internal_runtime_flags.idl': self.generate_idl,
'internal_runtime_flags.h': self.generate_header,
}
@template_expander.use_jinja('templates/internal_runtime_flags.idl.tmpl')
def generate_idl(self):
return {
'features': self._features,
'input_files': self._input_files,
'standard_features': self._standard_features,
}
@template_expander.use_jinja('templates/internal_runtime_flags.h.tmpl')
def generate_header(self):
return {
'features': self._features,
'feature_sets': self._feature_sets(),
'input_files': self._input_files,
'standard_features': self._standard_features,
'header_guard': self._header_guard,
}
if __name__ == '__main__':
json5_generator.Maker(InternalRuntimeFlagsWriter).main()
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import json5_generator
import make_runtime_features
import template_expander
# We want exactly the same parsing as RuntimeFeatureWriter but generate
# different files.
class OriginTrialsWriter(make_runtime_features.BaseRuntimeFeatureWriter):
file_basename = 'web_origin_trials'
def __init__(self, json5_file_path, output_dir):
super(OriginTrialsWriter, self).__init__(json5_file_path, output_dir)
self._outputs = {
(self.file_basename + '.cc'): self.generate_implementation,
}
@template_expander.use_jinja('templates/' + file_basename + '.cc.tmpl')
def generate_implementation(self):
return {
'features': self._features,
'origin_trial_features': self._origin_trial_features,
'input_files': self._input_files,
}
if __name__ == '__main__':
json5_generator.Maker(OriginTrialsWriter).main()
("api_class value for " + property_['api_class'] +
" should be None, True or a string")
return property_['api_class']
@template_expander.use_jinja(
'core/css/properties/templates/CSSPropertyAPI.h.tmpl')
def generate_property_api_header(self):
return {
'input_files': self._input_files,
'api_classnames': self._api_classes,
'api_classes_by_property_id': self._api_classes_by_property_id,
}
@template_expander.use_jinja(
'core/css/properties/templates/CSSPropertyAPI.cpp.tmpl')
def generate_property_api_implementation(self):
return {
'input_files':
self._input_files,
'api_classnames':
self._api_classes,
'api_classes_by_property_id':
self._api_classes_by_property_id,
'last_property_id':
(self._first_enum_value + len(self._properties) - 1)
}
if __name__ == '__main__':
json5_generator.Maker(CSSPropertyAPIWriter).main()
property_['longhands'])
for longhand in property_['longhand_property_ids']:
self._longhand_dictionary[longhand].append(property_)
for longhands in self._longhand_dictionary.values():
# Sort first by number of longhands in decreasing order, then
# alphabetically
longhands.sort(key=lambda property_: (-len(property_[
'longhand_property_ids']), property_['name']))
@template_expander.use_jinja(
'core/css/templates/style_property_shorthand.cc.tmpl')
def generate_style_property_shorthand_cpp(self):
return {
'input_files': self._input_files,
'properties': self._shorthands,
'longhands_dictionary': self._longhand_dictionary,
}
@template_expander.use_jinja(
'core/css/templates/style_property_shorthand.h.tmpl')
def generate_style_property_shorthand_h(self):
return {
'input_files': self._input_files,
'properties': self._shorthands,
}
if __name__ == '__main__':
json5_generator.Maker(StylePropertyShorthandWriter).main()
@template_expander.use_jinja('templates/style_builder_functions.h.tmpl',
filters=filters)
def generate_style_builder_functions_h(self):
return {
'input_files': self._input_files,
'properties': self._properties,
}
@template_expander.use_jinja('templates/style_builder_functions.cc.tmpl',
filters=filters)
def generate_style_builder_functions_cpp(self):
return {
'input_files': self._input_files,
'properties': self._properties,
'properties_by_id': self._json5_properties.properties_by_id,
}
@template_expander.use_jinja('templates/style_builder.cc.tmpl',
filters=filters)
def generate_style_builder(self):
return {
'input_files': self._input_files,
'properties': self._properties,
'properties_by_id': self._json5_properties.properties_by_id,
}
if __name__ == '__main__':
json5_generator.Maker(StyleBuilderWriter).main()
namespace_uri,
'tags':
self.tags_json5_file.name_dictionaries
if self.tags_json5_file else [],
'this_include_path':
qualified_header,
'use_namespace_for_attrs':
use_namespace_for_attrs,
}
def _metadata(self, name):
metadata = self.attrs_json5_file.metadata[name].strip('"')
if self.tags_json5_file:
assert metadata == self.tags_json5_file.metadata[name].strip(
'"'), 'Both files must have the same %s.' % name
return metadata
@template_expander.use_jinja('templates/make_qualified_names.h.tmpl',
filters=filters)
def generate_header(self):
return self._template_context
@template_expander.use_jinja('templates/make_qualified_names.cc.tmpl',
filters=filters)
def generate_implementation(self):
return self._template_context
if __name__ == "__main__":
json5_generator.Maker(MakeQualifiedNamesWriter).main()
namespace = self.json5_file.metadata['namespace'].strip('"')
suffix = self.json5_file.metadata['suffix'].strip('"')
export = self.json5_file.metadata['export'].strip('"')
assert namespace, 'A namespace is required.'
self._outputs = {
(namespace + suffix + 'Names.h'): self.generate_header,
(namespace + suffix + 'Names.cpp'): self.generate_implementation,
}
self._template_context = {
'namespace': namespace,
'suffix': suffix,
'export': export,
'entries': self.json5_file.name_dictionaries,
'in_files': self.json5_file.file_paths,
}
@template_expander.use_jinja("MakeNames.h.tmpl", filters=filters)
def generate_header(self):
return self._template_context
@template_expander.use_jinja("MakeNames.cpp.tmpl", filters=filters)
def generate_implementation(self):
return self._template_context
if __name__ == "__main__":
json5_generator.Maker(MakeNamesWriter).main()
def get_attributes(properties):
attributes = get_camel_cased_attributes(properties) + \
get_webkit_cased_attributes(properties) + \
get_dashed_attributes(properties)
assert len(set(attributes)) == len(attributes), \
'There should be no overlap between the attribute categories'
return attributes
class CSSStyleDeclarationAttributeIDLWriter(json5_generator.Writer):
def __init__(self, json5_file_paths, output_dir):
super(CSSStyleDeclarationAttributeIDLWriter, self).__init__([],
output_dir)
assert len(json5_file_paths) == 3,\
('CSSStyleDeclarationAttributeIDLWriter requires 3 input json5 ' +
'files, got {}.'.format(len(json5_file_paths)))
properties = css_properties.CSSProperties(json5_file_paths)
self._attributes = get_attributes(properties.supported_properties)
self._outputs = {}
self._outputs[OUT_IDL] = self.generate_attributes_idl
@template_expander.use_jinja('core/css/templates/%s.tmpl' % OUT_IDL)
def generate_attributes_idl(self):
return {'attributes': self._attributes}
if __name__ == '__main__':
json5_generator.Maker(CSSStyleDeclarationAttributeIDLWriter).main()
for offset, descriptor in enumerate(self._descriptors):
descriptor['enum_value'] = first_descriptor_id + offset
self._character_offsets.append(chars_used)
chars_used += len(descriptor['name'].original)
self._longest_name_length = max(len(descriptor['name'].original),
len(descriptor['alias']),
self._longest_name_length)
@template_expander.use_jinja(
'core/css/parser/templates/at_rule_descriptors.h.tmpl')
def generate_header(self):
return {
'descriptors': self._descriptors,
'descriptors_count': self._descriptors_count
}
@gperf.use_jinja_gperf_template(
'core/css/parser/templates/at_rule_descriptors.cc.tmpl')
def generate_implementation(self):
return {
'descriptors': self._descriptors,
'descriptor_offsets': self._character_offsets,
'descriptors_count': len(self._descriptors),
'longest_name_length': self._longest_name_length,
'gperf_path': self.gperf_path
}
if __name__ == '__main__':
json5_generator.Maker(AtRuleNamesWriter).main()
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import sys
import json5_generator
import trie_builder
import template_expander
class UnitTrieWriter(json5_generator.Writer):
def __init__(self, json5_file_paths):
super(UnitTrieWriter, self).__init__(json5_file_paths)
self._units = {entry['name']: entry['unit_type'] for entry in self.json5_file.name_dictionaries}
self._outputs = {
'CSSPrimitiveValueUnitTrie.cpp': self.generate_implementation
}
@template_expander.use_jinja('templates/CSSPrimitiveValueUnitTrie.cpp.tmpl')
def generate_implementation(self):
return {
'input_files': self._input_files,
'length_tries': trie_builder.trie_list_by_str_length(self._units)
}
if __name__ == '__main__':
json5_generator.Maker(UnitTrieWriter).main()
runtime_to_document_policy_map[dependency].append(
feature['name'])
self._outputs = {
self.file_basename + '.cc':
template_expander.use_jinja(
'templates/' + self.file_basename + '.cc.tmpl')(lambda: {
'header_guard':
self.make_header_guard(self._relative_output_dir + self.
file_basename + '.h'),
'input_files':
self._input_files,
'feature_policy_features':
feature_policy_features,
'document_policy_features':
document_policy_features,
'fp_origin_trial_dependency_map':
fp_origin_trial_dependency_map,
'dp_origin_trial_dependency_map':
dp_origin_trial_dependency_map,
'runtime_to_feature_policy_map':
runtime_to_feature_policy_map,
'runtime_to_document_policy_map':
runtime_to_document_policy_map
}),
}
if __name__ == '__main__':
json5_generator.Maker(FeaturePolicyFeatureWriter).main()
'include_paths': self._include_paths,
'computed_style': self._root_group,
'diff_functions_map': self._diff_functions_map,
}
@template_expander.use_jinja('templates/ComputedStyleBase.cpp.tmpl',
tests={
'in': lambda a, b: a in b
})
def generate_base_computed_style_cpp(self):
return {
'input_files': self._input_files,
'properties': self._properties,
'enums': self._generated_enums,
'include_paths': self._include_paths,
'computed_style': self._root_group,
'diff_functions_map': self._diff_functions_map,
}
@template_expander.use_jinja('templates/ComputedStyleBaseConstants.h.tmpl')
def generate_base_computed_style_constants(self):
return {
'input_files': self._input_files,
'properties': self._properties,
'enums': self._generated_enums,
}
if __name__ == '__main__':
json5_generator.Maker(ComputedStyleBaseWriter).main()
tag['js_interface'] = tag['JSInterfaceName']
elements.add(tag['js_interface'])
for tag in tags:
tag['multipleTagNames'] = (interface_counts[tag['interface']] > 1
or tag['interface']
== self.fallback_interface)
@template_expander.use_jinja("templates/element_type_helpers.h.tmpl",
filters=filters)
def generate_helper_header(self):
return self._template_context
@template_expander.use_jinja("templates/element_type_helpers.cc.tmpl",
filters=filters)
def generate_helper_implementation(self):
return self._template_context
def _interface(self, tag):
if tag['interfaceName']:
return tag['interfaceName']
name = tag['name'].to_upper_camel_case()
# FIXME: We shouldn't hard-code HTML here.
if name == 'HTML':
name = 'Html'
return '%s%sElement' % (self.namespace, name)
if __name__ == "__main__":
json5_generator.Maker(MakeElementTypeHelpersWriter).main()
def _headers_header_includes(self, entries):
includes = {
'third_party/blink/renderer/core/execution_context/execution_context.h',
'third_party/blink/renderer/core/frame/deprecation.h',
'third_party/blink/renderer/platform/instrumentation/use_counter.h',
'third_party/blink/renderer/platform/runtime_enabled_features.h',
}
includes.update(map(self._headers_header_include_path, entries))
return sorted([x for x in includes if x])
@template_expander.use_jinja('templates/event_factory.cc.tmpl',
filters=filters)
def generate_implementation(self):
target_events = [
event for event in self.json5_file.name_dictionaries if
(create_event_ignore_case_list(event['name'].original) or
create_event_ignore_case_and_measure_list(event['name'].original))
]
return {
'include_header_paths':
self._headers_header_includes(target_events),
'input_files': self._input_files,
'suffix': self.suffix,
'events': target_events,
}
if __name__ == "__main__":
json5_generator.Maker(EventFactoryWriter).main()
def generate_implementation(self):
return self._template_inputs()
class RuntimeFeatureTestHelpersWriter(BaseRuntimeFeatureWriter):
class_name = 'ScopedRuntimeEnabledFeatureForTest'
file_basename = 'runtime_enabled_features_test_helpers'
def __init__(self, json5_file_path, output_dir):
super(RuntimeFeatureTestHelpersWriter,
self).__init__(json5_file_path, output_dir)
self._outputs = {
('testing/' + self.file_basename + '.h'): self.generate_header
}
def _template_inputs(self):
return {
'features': self._features,
'input_files': self._input_files,
'header_guard': self._header_guard,
}
@template_expander.use_jinja('templates/' + file_basename + '.h.tmpl')
def generate_header(self):
return self._template_inputs()
if __name__ == '__main__':
json5_generator.Maker(RuntimeFeatureWriter).main()
json5_generator.Maker(RuntimeFeatureTestHelpersWriter).main()
self.json5_file.name_dictionaries.sort(key=lambda entry: entry['name'])
self._outputs = {
('InternalSettingsGenerated.h'): self.generate_header,
('InternalSettingsGenerated.cpp'): self.generate_implementation,
('InternalSettingsGenerated.idl'): self.generate_idl,
}
self._template_context = {
'settings': self.json5_file.name_dictionaries,
}
@template_expander.use_jinja('InternalSettingsGenerated.h.tmpl',
filters=filters)
def generate_header(self):
return self._template_context
@template_expander.use_jinja('InternalSettingsGenerated.cpp.tmpl',
filters=filters)
def generate_implementation(self):
return self._template_context
@template_expander.use_jinja('InternalSettingsGenerated.idl.tmpl',
filters=filters)
def generate_idl(self):
return self._template_context
if __name__ == '__main__':
json5_generator.Maker(MakeInternalSettingsWriter).main()
for single_type in property_['typedom_types']:
types.append(single_type)
property_['typedom_types'] = types
# Generate CSSValueID values from keywords.
property_['keywordIDs'] = map(enum_key_for_css_keyword,
property_['keywords'])
self._outputs = {
'cssom_types.cc': self.generate_types,
'cssom_keywords.cc': self.generate_keywords,
}
@template_expander.use_jinja('core/css/templates/cssom_types.cc.tmpl')
def generate_types(self):
return {
'input_files': self._input_files,
'properties': self._properties,
}
@template_expander.use_jinja('core/css/templates/cssom_keywords.cc.tmpl')
def generate_keywords(self):
return {
'input_files': self._input_files,
'properties': self._properties,
}
if __name__ == '__main__':
json5_generator.Maker(CSSOMTypesWriter).main()
filters = {
'lower_first': lower_first,
}
def __init__(self, json5_file_path):
super(CSSPropertyMetadataWriter, self).__init__(json5_file_path)
self._outputs = {
'CSSPropertyMetadata.cpp': self.generate_css_property_metadata_cpp
}
@template_expander.use_jinja('CSSPropertyMetadata.cpp.tmpl',
filters=filters)
def generate_css_property_metadata_cpp(self):
return {
'properties_including_aliases':
self._properties_including_aliases,
'switches': [
('is_descriptor', 'isDescriptor'),
('is_property', 'isProperty'),
('interpolable', 'isInterpolableProperty'),
('inherited', 'isInheritedProperty'),
('supports_percentage', 'propertySupportsPercentage'),
],
'first_enum_value':
self._first_enum_value,
}
if __name__ == '__main__':
json5_generator.Maker(CSSPropertyMetadataWriter).main()
# found in the LICENSE file.
import json5_generator
import template_expander
from make_document_policy_features_util import parse_default_value
class DocumentPolicyFeatureWriter(json5_generator.Writer):
file_basename = 'document_policy_features'
def __init__(self, json5_file_path, output_dir):
super(DocumentPolicyFeatureWriter,
self).__init__(json5_file_path, output_dir)
@template_expander.use_jinja('templates/' + self.file_basename +
'.cc.tmpl')
def generate_implementation():
return {
'input_files': self._input_files,
'features': self.json5_file.name_dictionaries,
'parse_default_value': parse_default_value
}
self._outputs = {
self.file_basename + '.cc': generate_implementation,
}
if __name__ == '__main__':
json5_generator.Maker(DocumentPolicyFeatureWriter).main()
