| # Copyright 2016 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=import-error,print-statement,relative-import |
| |
| """Generates Web Agent API bindings. |
| |
| The Web Agent API bindings provide a stable, IDL-generated interface for the |
| Web Agents. |
| |
| The Web Agents are the high-level services like Autofill, |
| Autocomplete, Translate, Distiller, Phishing Detector, and others. Web Agents |
| typically want to introspec the document and rendering infromation to implement |
| browser features. |
| |
| The bindings are meant to be as simple and as ephemeral as possible, mostly just |
| wrapping existing DOM classes. Their primary goal is to avoid leaking the actual |
| DOM classes to the Web Agents layer. |
| """ |
| |
| import os |
| import posixpath |
| |
| from code_generator import CodeGeneratorBase, render_template |
| # TODO(dglazkov): Move TypedefResolver to code_generator.py |
| from code_generator_v8 import TypedefResolver |
| from name_style_converter import NameStyleConverter |
| |
| MODULE_PYNAME = os.path.splitext(os.path.basename(__file__))[0] + '.py' |
| |
| STRING_INCLUDE_PATH = 'wtf/text/WTFString.h' |
| WEB_AGENT_API_IDL_ATTRIBUTE = 'WebAgentAPI' |
| |
| |
| def interface_context(idl_interface, type_resolver): |
| builder = InterfaceContextBuilder(MODULE_PYNAME, type_resolver) |
| builder.set_class_name(idl_interface.name) |
| builder.set_inheritance(idl_interface.parent) |
| |
| for idl_attribute in idl_interface.attributes: |
| builder.add_attribute(idl_attribute) |
| |
| for idl_operation in idl_interface.operations: |
| builder.add_operation(idl_operation) |
| |
| return builder.build() |
| |
| |
| class TypeResolver(object): |
| """Resolves Web IDL types into corresponding C++ types and include paths |
| to the generated and existing files.""" |
| |
| def __init__(self, interfaces_info): |
| self.interfaces_info = interfaces_info |
| |
| def includes_from_interface(self, interface_name): |
| interface_info = self.interfaces_info.get(interface_name) |
| if interface_info is None: |
| raise KeyError('Unknown interface "%s".' % interface_name) |
| return set([interface_info['include_path']]) |
| |
| def _includes_from_type(self, idl_type): |
| if idl_type.is_void: |
| return set() |
| if idl_type.is_primitive_type: |
| return set() |
| if idl_type.is_string_type: |
| return set([STRING_INCLUDE_PATH]) |
| |
| # TODO(dglazkov): Handle complex/weird types. |
| return self.includes_from_interface(idl_type.base_type) |
| |
| def includes_from_definition(self, idl_definition): |
| return self._includes_from_type(idl_definition.idl_type) |
| |
| def type_from_definition(self, idl_definition): |
| # TODO(dglazkov): The output of this method must be a reasonable C++ |
| # type that can be used directly in the jinja2 template. |
| return idl_definition.idl_type.base_type |
| |
| def base_class_includes(self): |
| return set(['platform/heap/Handle.h']) |
| |
| |
| class InterfaceContextBuilder(object): |
| def __init__(self, code_generator, type_resolver): |
| self.result = {'code_generator': code_generator} |
| self.type_resolver = type_resolver |
| |
| def set_class_name(self, class_name): |
| converter = NameStyleConverter(class_name) |
| self.result['class_name'] = converter.to_all_cases() |
| self._ensure_set('cpp_includes').update( |
| self.type_resolver.includes_from_interface(class_name)) |
| |
| def set_inheritance(self, base_interface): |
| if base_interface is None: |
| self._ensure_set('header_includes').update( |
| self.type_resolver.base_class_includes()) |
| return |
| self.result['base_class'] = base_interface |
| self._ensure_set('header_includes').update( |
| self.type_resolver.includes_from_interface(base_interface)) |
| |
| def _ensure_set(self, name): |
| return self.result.setdefault(name, set()) |
| |
| def _ensure_list(self, name): |
| return self.result.setdefault(name, []) |
| |
| def add_attribute(self, idl_attribute): |
| self._ensure_list('attributes').append( |
| self.create_attribute(idl_attribute)) |
| self._ensure_set('cpp_includes').update( |
| self.type_resolver.includes_from_definition(idl_attribute)) |
| |
| def add_operation(self, idl_operation): |
| if not idl_operation.name: |
| return |
| self._ensure_list('methods').append( |
| self.create_method(idl_operation)) |
| self._ensure_set('cpp_includes').update( |
| self.type_resolver.includes_from_definition(idl_operation)) |
| |
| def create_method(self, idl_operation): |
| name = idl_operation.name |
| return_type = self.type_resolver.type_from_definition(idl_operation) |
| return { |
| 'name': name, |
| 'return_type': return_type |
| } |
| |
| def create_attribute(self, idl_attribute): |
| name = idl_attribute.name |
| return_type = self.type_resolver.type_from_definition(idl_attribute) |
| return { |
| 'name': name, |
| 'return_type': return_type |
| } |
| |
| def build(self): |
| return self.result |
| |
| |
| class CodeGeneratorWebAgentAPI(CodeGeneratorBase): |
| def __init__(self, info_provider, cache_dir, output_dir): |
| CodeGeneratorBase.__init__(self, MODULE_PYNAME, info_provider, |
| cache_dir, output_dir) |
| self.type_resolver = TypeResolver(info_provider.interfaces_info) |
| self.typedef_resolver = TypedefResolver(info_provider) |
| |
| def get_template(self, file_extension): |
| template_filename = 'web_agent_api_interface.%s.tmpl' % file_extension |
| return self.jinja_env.get_template(template_filename) |
| |
| def generate_file(self, template_context, file_extension): |
| template = self.get_template(file_extension) |
| path = posixpath.join( |
| self.output_dir, |
| '%s.%s' % (template_context['class_name']['snake_case'], |
| file_extension)) |
| text = render_template(template, template_context) |
| return (path, text) |
| |
| def generate_interface_code(self, interface): |
| # TODO(dglazkov): Implement callback interfaces. |
| # TODO(dglazkov): Make sure partial interfaces are handled. |
| if interface.is_callback or interface.is_partial: |
| raise ValueError('Partial or callback interfaces are not supported') |
| |
| template_context = interface_context(interface, self.type_resolver) |
| |
| return ( |
| self.generate_file(template_context, 'h'), |
| self.generate_file(template_context, 'cc') |
| ) |
| |
| def generate_code(self, definitions, definition_name): |
| self.typedef_resolver.resolve(definitions, definition_name) |
| |
| # TODO(dglazkov): Implement dictionaries |
| if definition_name not in definitions.interfaces: |
| return None |
| |
| interface = definitions.interfaces[definition_name] |
| if WEB_AGENT_API_IDL_ATTRIBUTE not in interface.extended_attributes: |
| return None |
| |
| return self.generate_interface_code(interface) |
