[inspector] use own version of third_party/inspector_protocol
When Chromium and V8 use the same version of inspector_protocol, any protocol change takes at least 4 patches and 3 waiting for rolls.
To simplify this process we need to have two diffrent versions of inspector_protocol in Chromium and V8. Current state of inspector_protocol was extracted into separate repository [1]. This CL puts last version of inspector_protocol into third_party/inspector_protocol.
[1] https://chromium.googlesource.com/deps/inspector_protocol/
V8 CL: https://codereview.chromium.org/2447323002/
BUG=chromium:637032
[email protected]
Review-Url: https://codereview.chromium.org/2452853002
Cr-Original-Commit-Position: refs/heads/master@{#428605}
Cr-Mirrored-From: https://chromium.googlesource.com/chromium/src
Cr-Mirrored-Commit: c8c595193c5d06bb4870c975231aae1f943246f0
diff --git a/CheckProtocolCompatibility.py b/CheckProtocolCompatibility.py
deleted file mode 100755
index dd9acad..0000000
--- a/CheckProtocolCompatibility.py
+++ /dev/null
@@ -1,479 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2011 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
-# in the documentation and/or other materials provided with the
-# distribution.
-# * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-# Inspector protocol validator.
-#
-# Tests that subsequent protocol changes are not breaking backwards compatibility.
-# Following violations are reported:
-#
-# - Domain has been removed
-# - Command has been removed
-# - Required command parameter was added or changed from optional
-# - Required response parameter was removed or changed to optional
-# - Event has been removed
-# - Required event parameter was removed or changed to optional
-# - Parameter type has changed.
-#
-# For the parameters with composite types the above checks are also applied
-# recursively to every property of the type.
-#
-# Adding --show_changes to the command line prints out a list of valid public API changes.
-
-import copy
-import os.path
-import optparse
-import sys
-
-try:
- import json
-except ImportError:
- import simplejson as json
-
-
-def list_to_map(items, key):
- result = {}
- for item in items:
- if "experimental" not in item and "hidden" not in item:
- result[item[key]] = item
- return result
-
-
-def named_list_to_map(container, name, key):
- if name in container:
- return list_to_map(container[name], key)
- return {}
-
-
-def removed(reverse):
- if reverse:
- return "added"
- return "removed"
-
-
-def required(reverse):
- if reverse:
- return "optional"
- return "required"
-
-
-def compare_schemas(d_1, d_2, reverse):
- errors = []
- domains_1 = copy.deepcopy(d_1)
- domains_2 = copy.deepcopy(d_2)
- types_1 = normalize_types_in_schema(domains_1)
- types_2 = normalize_types_in_schema(domains_2)
-
- domains_by_name_1 = list_to_map(domains_1, "domain")
- domains_by_name_2 = list_to_map(domains_2, "domain")
-
- for name in domains_by_name_1:
- domain_1 = domains_by_name_1[name]
- if name not in domains_by_name_2:
- errors.append("%s: domain has been %s" % (name, removed(reverse)))
- continue
- compare_domains(domain_1, domains_by_name_2[name], types_1, types_2, errors, reverse)
- return errors
-
-
-def compare_domains(domain_1, domain_2, types_map_1, types_map_2, errors, reverse):
- domain_name = domain_1["domain"]
- commands_1 = named_list_to_map(domain_1, "commands", "name")
- commands_2 = named_list_to_map(domain_2, "commands", "name")
- for name in commands_1:
- command_1 = commands_1[name]
- if name not in commands_2:
- errors.append("%s.%s: command has been %s" % (domain_1["domain"], name, removed(reverse)))
- continue
- compare_commands(domain_name, command_1, commands_2[name], types_map_1, types_map_2, errors, reverse)
-
- events_1 = named_list_to_map(domain_1, "events", "name")
- events_2 = named_list_to_map(domain_2, "events", "name")
- for name in events_1:
- event_1 = events_1[name]
- if name not in events_2:
- errors.append("%s.%s: event has been %s" % (domain_1["domain"], name, removed(reverse)))
- continue
- compare_events(domain_name, event_1, events_2[name], types_map_1, types_map_2, errors, reverse)
-
-
-def compare_commands(domain_name, command_1, command_2, types_map_1, types_map_2, errors, reverse):
- context = domain_name + "." + command_1["name"]
-
- params_1 = named_list_to_map(command_1, "parameters", "name")
- params_2 = named_list_to_map(command_2, "parameters", "name")
- # Note the reversed order: we allow removing but forbid adding parameters.
- compare_params_list(context, "parameter", params_2, params_1, types_map_2, types_map_1, 0, errors, not reverse)
-
- returns_1 = named_list_to_map(command_1, "returns", "name")
- returns_2 = named_list_to_map(command_2, "returns", "name")
- compare_params_list(context, "response parameter", returns_1, returns_2, types_map_1, types_map_2, 0, errors, reverse)
-
-
-def compare_events(domain_name, event_1, event_2, types_map_1, types_map_2, errors, reverse):
- context = domain_name + "." + event_1["name"]
- params_1 = named_list_to_map(event_1, "parameters", "name")
- params_2 = named_list_to_map(event_2, "parameters", "name")
- compare_params_list(context, "parameter", params_1, params_2, types_map_1, types_map_2, 0, errors, reverse)
-
-
-def compare_params_list(context, kind, params_1, params_2, types_map_1, types_map_2, depth, errors, reverse):
- for name in params_1:
- param_1 = params_1[name]
- if name not in params_2:
- if "optional" not in param_1:
- errors.append("%s.%s: required %s has been %s" % (context, name, kind, removed(reverse)))
- continue
-
- param_2 = params_2[name]
- if param_2 and "optional" in param_2 and "optional" not in param_1:
- errors.append("%s.%s: %s %s is now %s" % (context, name, required(reverse), kind, required(not reverse)))
- continue
- type_1 = extract_type(param_1, types_map_1, errors)
- type_2 = extract_type(param_2, types_map_2, errors)
- compare_types(context + "." + name, kind, type_1, type_2, types_map_1, types_map_2, depth, errors, reverse)
-
-
-def compare_types(context, kind, type_1, type_2, types_map_1, types_map_2, depth, errors, reverse):
- if depth > 10:
- return
-
- base_type_1 = type_1["type"]
- base_type_2 = type_2["type"]
-
- if base_type_1 != base_type_2:
- errors.append("%s: %s base type mismatch, '%s' vs '%s'" % (context, kind, base_type_1, base_type_2))
- elif base_type_1 == "object":
- params_1 = named_list_to_map(type_1, "properties", "name")
- params_2 = named_list_to_map(type_2, "properties", "name")
- # If both parameters have the same named type use it in the context.
- if "id" in type_1 and "id" in type_2 and type_1["id"] == type_2["id"]:
- type_name = type_1["id"]
- else:
- type_name = "<object>"
- context += " %s->%s" % (kind, type_name)
- compare_params_list(context, "property", params_1, params_2, types_map_1, types_map_2, depth + 1, errors, reverse)
- elif base_type_1 == "array":
- item_type_1 = extract_type(type_1["items"], types_map_1, errors)
- item_type_2 = extract_type(type_2["items"], types_map_2, errors)
- compare_types(context, kind, item_type_1, item_type_2, types_map_1, types_map_2, depth + 1, errors, reverse)
-
-
-def extract_type(typed_object, types_map, errors):
- if "type" in typed_object:
- result = {"id": "<transient>", "type": typed_object["type"]}
- if typed_object["type"] == "object":
- result["properties"] = []
- elif typed_object["type"] == "array":
- result["items"] = typed_object["items"]
- return result
- elif "$ref" in typed_object:
- ref = typed_object["$ref"]
- if ref not in types_map:
- errors.append("Can not resolve type: %s" % ref)
- types_map[ref] = {"id": "<transient>", "type": "object"}
- return types_map[ref]
-
-
-def normalize_types_in_schema(domains):
- types = {}
- for domain in domains:
- domain_name = domain["domain"]
- normalize_types(domain, domain_name, types)
- return types
-
-
-def normalize_types(obj, domain_name, types):
- if isinstance(obj, list):
- for item in obj:
- normalize_types(item, domain_name, types)
- elif isinstance(obj, dict):
- for key, value in obj.items():
- if key == "$ref" and value.find(".") == -1:
- obj[key] = "%s.%s" % (domain_name, value)
- elif key == "id":
- obj[key] = "%s.%s" % (domain_name, value)
- types[obj[key]] = obj
- else:
- normalize_types(value, domain_name, types)
-
-
-def load_schema(file_name, domains):
- # pylint: disable=W0613
- if not os.path.isfile(file_name):
- return
- input_file = open(file_name, "r")
- json_string = input_file.read()
- parsed_json = json.loads(json_string)
- domains += parsed_json["domains"]
- return parsed_json["version"]
-
-
-def self_test():
- def create_test_schema_1():
- return [
- {
- "domain": "Network",
- "types": [
- {
- "id": "LoaderId",
- "type": "string"
- },
- {
- "id": "Headers",
- "type": "object"
- },
- {
- "id": "Request",
- "type": "object",
- "properties": [
- {"name": "url", "type": "string"},
- {"name": "method", "type": "string"},
- {"name": "headers", "$ref": "Headers"},
- {"name": "becameOptionalField", "type": "string"},
- {"name": "removedField", "type": "string"},
- ]
- }
- ],
- "commands": [
- {
- "name": "removedCommand",
- },
- {
- "name": "setExtraHTTPHeaders",
- "parameters": [
- {"name": "headers", "$ref": "Headers"},
- {"name": "mismatched", "type": "string"},
- {"name": "becameOptional", "$ref": "Headers"},
- {"name": "removedRequired", "$ref": "Headers"},
- {"name": "becameRequired", "$ref": "Headers", "optional": True},
- {"name": "removedOptional", "$ref": "Headers", "optional": True},
- ],
- "returns": [
- {"name": "mimeType", "type": "string"},
- {"name": "becameOptional", "type": "string"},
- {"name": "removedRequired", "type": "string"},
- {"name": "becameRequired", "type": "string", "optional": True},
- {"name": "removedOptional", "type": "string", "optional": True},
- ]
- }
- ],
- "events": [
- {
- "name": "requestWillBeSent",
- "parameters": [
- {"name": "frameId", "type": "string", "experimental": True},
- {"name": "request", "$ref": "Request"},
- {"name": "becameOptional", "type": "string"},
- {"name": "removedRequired", "type": "string"},
- {"name": "becameRequired", "type": "string", "optional": True},
- {"name": "removedOptional", "type": "string", "optional": True},
- ]
- },
- {
- "name": "removedEvent",
- "parameters": [
- {"name": "errorText", "type": "string"},
- {"name": "canceled", "type": "boolean", "optional": True}
- ]
- }
- ]
- },
- {
- "domain": "removedDomain"
- }
- ]
-
- def create_test_schema_2():
- return [
- {
- "domain": "Network",
- "types": [
- {
- "id": "LoaderId",
- "type": "string"
- },
- {
- "id": "Request",
- "type": "object",
- "properties": [
- {"name": "url", "type": "string"},
- {"name": "method", "type": "string"},
- {"name": "headers", "type": "object"},
- {"name": "becameOptionalField", "type": "string", "optional": True},
- ]
- }
- ],
- "commands": [
- {
- "name": "addedCommand",
- },
- {
- "name": "setExtraHTTPHeaders",
- "parameters": [
- {"name": "headers", "type": "object"},
- {"name": "mismatched", "type": "object"},
- {"name": "becameOptional", "type": "object", "optional": True},
- {"name": "addedRequired", "type": "object"},
- {"name": "becameRequired", "type": "object"},
- {"name": "addedOptional", "type": "object", "optional": True},
- ],
- "returns": [
- {"name": "mimeType", "type": "string"},
- {"name": "becameOptional", "type": "string", "optional": True},
- {"name": "addedRequired", "type": "string"},
- {"name": "becameRequired", "type": "string"},
- {"name": "addedOptional", "type": "string", "optional": True},
- ]
- }
- ],
- "events": [
- {
- "name": "requestWillBeSent",
- "parameters": [
- {"name": "request", "$ref": "Request"},
- {"name": "becameOptional", "type": "string", "optional": True},
- {"name": "addedRequired", "type": "string"},
- {"name": "becameRequired", "type": "string"},
- {"name": "addedOptional", "type": "string", "optional": True},
- ]
- },
- {
- "name": "addedEvent"
- }
- ]
- },
- {
- "domain": "addedDomain"
- }
- ]
-
- expected_errors = [
- "removedDomain: domain has been removed",
- "Network.removedCommand: command has been removed",
- "Network.removedEvent: event has been removed",
- "Network.setExtraHTTPHeaders.mismatched: parameter base type mismatch, 'object' vs 'string'",
- "Network.setExtraHTTPHeaders.addedRequired: required parameter has been added",
- "Network.setExtraHTTPHeaders.becameRequired: optional parameter is now required",
- "Network.setExtraHTTPHeaders.removedRequired: required response parameter has been removed",
- "Network.setExtraHTTPHeaders.becameOptional: required response parameter is now optional",
- "Network.requestWillBeSent.removedRequired: required parameter has been removed",
- "Network.requestWillBeSent.becameOptional: required parameter is now optional",
- "Network.requestWillBeSent.request parameter->Network.Request.removedField: required property has been removed",
- "Network.requestWillBeSent.request parameter->Network.Request.becameOptionalField: required property is now optional",
- ]
-
- expected_errors_reverse = [
- "addedDomain: domain has been added",
- "Network.addedEvent: event has been added",
- "Network.addedCommand: command has been added",
- "Network.setExtraHTTPHeaders.mismatched: parameter base type mismatch, 'string' vs 'object'",
- "Network.setExtraHTTPHeaders.removedRequired: required parameter has been removed",
- "Network.setExtraHTTPHeaders.becameOptional: required parameter is now optional",
- "Network.setExtraHTTPHeaders.addedRequired: required response parameter has been added",
- "Network.setExtraHTTPHeaders.becameRequired: optional response parameter is now required",
- "Network.requestWillBeSent.becameRequired: optional parameter is now required",
- "Network.requestWillBeSent.addedRequired: required parameter has been added",
- ]
-
- def is_subset(subset, superset, message):
- for i in range(len(subset)):
- if subset[i] not in superset:
- sys.stderr.write("%s error: %s\n" % (message, subset[i]))
- return False
- return True
-
- def errors_match(expected, actual):
- return (is_subset(actual, expected, "Unexpected") and
- is_subset(expected, actual, "Missing"))
-
- return (errors_match(expected_errors,
- compare_schemas(create_test_schema_1(), create_test_schema_2(), False)) and
- errors_match(expected_errors_reverse,
- compare_schemas(create_test_schema_2(), create_test_schema_1(), True)))
-
-
-def load_domains_and_baselines(file_name, domains, baseline_domains):
- version = load_schema(os.path.normpath(file_name), domains)
- suffix = "-%s.%s.json" % (version["major"], version["minor"])
- baseline_file = file_name.replace(".json", suffix)
- load_schema(os.path.normpath(baseline_file), baseline_domains)
- return version
-
-
-def main():
- if not self_test():
- sys.stderr.write("Self-test failed")
- return 1
-
- cmdline_parser = optparse.OptionParser()
- cmdline_parser.add_option("--show_changes")
- cmdline_parser.add_option("--expected_errors")
- cmdline_parser.add_option("--stamp")
- arg_options, arg_values = cmdline_parser.parse_args()
-
- if len(arg_values) < 1:
- sys.stderr.write("Usage: %s [--show_changes] <protocol-1> [, <protocol-2>...]\n" % sys.argv[0])
- return 1
-
- domains = []
- baseline_domains = []
- version = load_domains_and_baselines(arg_values[0], domains, baseline_domains)
- for dependency in arg_values[1:]:
- load_domains_and_baselines(dependency, domains, baseline_domains)
-
- expected_errors = []
- if arg_options.expected_errors:
- expected_errors_file = open(arg_options.expected_errors, "r")
- expected_errors = json.loads(expected_errors_file.read())["errors"]
- expected_errors_file.close()
-
- errors = compare_schemas(baseline_domains, domains, False)
- unexpected_errors = []
- for i in range(len(errors)):
- if errors[i] not in expected_errors:
- unexpected_errors.append(errors[i])
- if len(unexpected_errors) > 0:
- sys.stderr.write(" Compatibility checks FAILED\n")
- for error in unexpected_errors:
- sys.stderr.write(" %s\n" % error)
- return 1
-
- if arg_options.show_changes:
- changes = compare_schemas(domains, baseline_domains, True)
- if len(changes) > 0:
- print " Public changes since %s:" % version
- for change in changes:
- print " %s" % change
-
- if arg_options.stamp:
- with open(arg_options.stamp, 'a') as _:
- pass
-
-if __name__ == '__main__':
- sys.exit(main())
diff --git a/CodeGenerator.py b/CodeGenerator.py
deleted file mode 100644
index 97eda50..0000000
--- a/CodeGenerator.py
+++ /dev/null
@@ -1,499 +0,0 @@
-# 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.
-
-import os.path
-import sys
-import optparse
-import collections
-import functools
-try:
- import json
-except ImportError:
- import simplejson as json
-
-# Path handling for libraries and templates
-# Paths have to be normalized because Jinja uses the exact template path to
-# determine the hash used in the cache filename, and we need a pre-caching step
-# to be concurrency-safe. Use absolute path because __file__ is absolute if
-# module is imported, and relative if executed directly.
-# If paths differ between pre-caching and individual file compilation, the cache
-# is regenerated, which causes a race condition and breaks concurrent build,
-# since some compile processes will try to read the partially written cache.
-module_path, module_filename = os.path.split(os.path.realpath(__file__))
-
-def read_config():
- # pylint: disable=W0703
- def json_to_object(data, output_base, config_base):
- def json_object_hook(object_dict):
- items = [(k, os.path.join(config_base, v) if k == "path" else v) for (k, v) in object_dict.items()]
- items = [(k, os.path.join(output_base, v) if k == "output" else v) for (k, v) in items]
- keys, values = zip(*items)
- return collections.namedtuple('X', keys)(*values)
- return json.loads(data, object_hook=json_object_hook)
-
- def init_defaults(config_tuple, path, defaults):
- keys = list(config_tuple._fields) # pylint: disable=E1101
- values = [getattr(config_tuple, k) for k in keys]
- for i in xrange(len(keys)):
- if hasattr(values[i], "_fields"):
- values[i] = init_defaults(values[i], path + "." + keys[i], defaults)
- for optional in defaults:
- if optional.find(path + ".") != 0:
- continue
- optional_key = optional[len(path) + 1:]
- if optional_key.find(".") == -1 and optional_key not in keys:
- keys.append(optional_key)
- values.append(defaults[optional])
- return collections.namedtuple('X', keys)(*values)
-
- try:
- cmdline_parser = optparse.OptionParser()
- cmdline_parser.add_option("--output_base")
- cmdline_parser.add_option("--jinja_dir")
- cmdline_parser.add_option("--config")
- arg_options, _ = cmdline_parser.parse_args()
- jinja_dir = arg_options.jinja_dir
- if not jinja_dir:
- raise Exception("jinja directory must be specified")
- output_base = arg_options.output_base
- if not output_base:
- raise Exception("Base output directory must be specified")
- config_file = arg_options.config
- if not config_file:
- raise Exception("Config file name must be specified")
- config_base = os.path.dirname(config_file)
- except Exception:
- # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.html
- exc = sys.exc_info()[1]
- sys.stderr.write("Failed to parse command-line arguments: %s\n\n" % exc)
- exit(1)
-
- try:
- config_json_file = open(config_file, "r")
- config_json_string = config_json_file.read()
- config_partial = json_to_object(config_json_string, output_base, config_base)
- config_json_file.close()
- defaults = {
- ".imported": False,
- ".imported.export_macro": "",
- ".imported.export_header": False,
- ".imported.header": False,
- ".imported.package": False,
- ".protocol.export_macro": "",
- ".protocol.export_header": False,
- ".exported": False,
- ".exported.export_macro": "",
- ".exported.export_header": False,
- ".lib": False,
- ".lib.export_macro": "",
- ".lib.export_header": False,
- }
- return (jinja_dir, config_file, init_defaults(config_partial, "", defaults))
- except Exception:
- # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.html
- exc = sys.exc_info()[1]
- sys.stderr.write("Failed to parse config file: %s\n\n" % exc)
- exit(1)
-
-
-def to_title_case(name):
- return name[:1].upper() + name[1:]
-
-
-def dash_to_camelcase(word):
- prefix = ""
- if word[0] == "-":
- prefix = "Negative"
- word = word[1:]
- return prefix + "".join(to_title_case(x) or "-" for x in word.split("-"))
-
-
-def initialize_jinja_env(jinja_dir, cache_dir):
- # pylint: disable=F0401
- sys.path.insert(1, os.path.abspath(jinja_dir))
- import jinja2
-
- jinja_env = jinja2.Environment(
- loader=jinja2.FileSystemLoader(module_path),
- # 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({"to_title_case": to_title_case, "dash_to_camelcase": dash_to_camelcase})
- jinja_env.add_extension("jinja2.ext.loopcontrols")
- return jinja_env
-
-
-def patch_full_qualified_refs(protocol):
- def patch_full_qualified_refs_in_domain(json, domain_name):
- if isinstance(json, list):
- for item in json:
- patch_full_qualified_refs_in_domain(item, domain_name)
-
- if not isinstance(json, dict):
- return
- for key in json:
- if key == "type" and json[key] == "string":
- json[key] = domain_name + ".string"
- if key != "$ref":
- patch_full_qualified_refs_in_domain(json[key], domain_name)
- continue
- if json["$ref"].find(".") == -1:
- json["$ref"] = domain_name + "." + json["$ref"]
- return
-
- for domain in protocol.json_api["domains"]:
- patch_full_qualified_refs_in_domain(domain, domain["domain"])
-
-
-def calculate_exports(protocol):
- def calculate_exports_in_json(json_value):
- has_exports = False
- if isinstance(json_value, list):
- for item in json_value:
- has_exports = calculate_exports_in_json(item) or has_exports
- if isinstance(json_value, dict):
- has_exports = ("exported" in json_value and json_value["exported"]) or has_exports
- for key in json_value:
- has_exports = calculate_exports_in_json(json_value[key]) or has_exports
- return has_exports
-
- protocol.json_api["has_exports"] = False
- for domain_json in protocol.json_api["domains"]:
- domain_json["has_exports"] = calculate_exports_in_json(domain_json)
- if domain_json["has_exports"] and domain_json["domain"] in protocol.generate_domains:
- protocol.json_api["has_exports"] = True
-
-
-def create_imported_type_definition(domain_name, type, imported_namespace):
- # pylint: disable=W0622
- return {
- "return_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
- "pass_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
- "to_raw_type": "%s.get()",
- "to_pass_type": "std::move(%s)",
- "to_rvalue": "std::move(%s)",
- "type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
- "raw_type": "%s::%s::API::%s" % (imported_namespace, domain_name, type["id"]),
- "raw_pass_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type["id"]),
- "raw_return_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type["id"]),
- }
-
-
-def create_user_type_definition(domain_name, type):
- # pylint: disable=W0622
- return {
- "return_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
- "pass_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
- "to_raw_type": "%s.get()",
- "to_pass_type": "std::move(%s)",
- "to_rvalue": "std::move(%s)",
- "type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
- "raw_type": "protocol::%s::%s" % (domain_name, type["id"]),
- "raw_pass_type": "protocol::%s::%s*" % (domain_name, type["id"]),
- "raw_return_type": "protocol::%s::%s*" % (domain_name, type["id"]),
- }
-
-
-def create_object_type_definition():
- # pylint: disable=W0622
- return {
- "return_type": "std::unique_ptr<protocol::DictionaryValue>",
- "pass_type": "std::unique_ptr<protocol::DictionaryValue>",
- "to_raw_type": "%s.get()",
- "to_pass_type": "std::move(%s)",
- "to_rvalue": "std::move(%s)",
- "type": "std::unique_ptr<protocol::DictionaryValue>",
- "raw_type": "protocol::DictionaryValue",
- "raw_pass_type": "protocol::DictionaryValue*",
- "raw_return_type": "protocol::DictionaryValue*",
- }
-
-
-def create_any_type_definition():
- # pylint: disable=W0622
- return {
- "return_type": "std::unique_ptr<protocol::Value>",
- "pass_type": "std::unique_ptr<protocol::Value>",
- "to_raw_type": "%s.get()",
- "to_pass_type": "std::move(%s)",
- "to_rvalue": "std::move(%s)",
- "type": "std::unique_ptr<protocol::Value>",
- "raw_type": "protocol::Value",
- "raw_pass_type": "protocol::Value*",
- "raw_return_type": "protocol::Value*",
- }
-
-
-def create_string_type_definition():
- # pylint: disable=W0622
- return {
- "return_type": "String",
- "pass_type": "const String&",
- "to_pass_type": "%s",
- "to_raw_type": "%s",
- "to_rvalue": "%s",
- "type": "String",
- "raw_type": "String",
- "raw_pass_type": "const String&",
- "raw_return_type": "String",
- }
-
-
-def create_primitive_type_definition(type):
- # pylint: disable=W0622
- typedefs = {
- "number": "double",
- "integer": "int",
- "boolean": "bool"
- }
- defaults = {
- "number": "0",
- "integer": "0",
- "boolean": "false"
- }
- jsontypes = {
- "number": "TypeDouble",
- "integer": "TypeInteger",
- "boolean": "TypeBoolean",
- }
- return {
- "return_type": typedefs[type],
- "pass_type": typedefs[type],
- "to_pass_type": "%s",
- "to_raw_type": "%s",
- "to_rvalue": "%s",
- "type": typedefs[type],
- "raw_type": typedefs[type],
- "raw_pass_type": typedefs[type],
- "raw_return_type": typedefs[type],
- "default_value": defaults[type]
- }
-
-
-def wrap_array_definition(type):
- # pylint: disable=W0622
- return {
- "return_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
- "pass_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
- "to_raw_type": "%s.get()",
- "to_pass_type": "std::move(%s)",
- "to_rvalue": "std::move(%s)",
- "type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
- "raw_type": "protocol::Array<%s>" % type["raw_type"],
- "raw_pass_type": "protocol::Array<%s>*" % type["raw_type"],
- "raw_return_type": "protocol::Array<%s>*" % type["raw_type"],
- "create_type": "wrapUnique(new protocol::Array<%s>())" % type["raw_type"],
- "out_type": "protocol::Array<%s>&" % type["raw_type"],
- }
-
-
-def create_type_definitions(protocol, imported_namespace):
- protocol.type_definitions = {}
- protocol.type_definitions["number"] = create_primitive_type_definition("number")
- protocol.type_definitions["integer"] = create_primitive_type_definition("integer")
- protocol.type_definitions["boolean"] = create_primitive_type_definition("boolean")
- protocol.type_definitions["object"] = create_object_type_definition()
- protocol.type_definitions["any"] = create_any_type_definition()
- for domain in protocol.json_api["domains"]:
- protocol.type_definitions[domain["domain"] + ".string"] = create_string_type_definition()
- if not ("types" in domain):
- continue
- for type in domain["types"]:
- type_name = domain["domain"] + "." + type["id"]
- if type["type"] == "object" and domain["domain"] in protocol.imported_domains:
- protocol.type_definitions[type_name] = create_imported_type_definition(domain["domain"], type, imported_namespace)
- elif type["type"] == "object":
- protocol.type_definitions[type_name] = create_user_type_definition(domain["domain"], type)
- elif type["type"] == "array":
- items_type = type["items"]["type"]
- protocol.type_definitions[type_name] = wrap_array_definition(protocol.type_definitions[items_type])
- elif type["type"] == domain["domain"] + ".string":
- protocol.type_definitions[type_name] = create_string_type_definition()
- else:
- protocol.type_definitions[type_name] = create_primitive_type_definition(type["type"])
-
-
-def type_definition(protocol, name):
- return protocol.type_definitions[name]
-
-
-def resolve_type(protocol, prop):
- if "$ref" in prop:
- return protocol.type_definitions[prop["$ref"]]
- if prop["type"] == "array":
- return wrap_array_definition(resolve_type(protocol, prop["items"]))
- return protocol.type_definitions[prop["type"]]
-
-
-def join_arrays(dict, keys):
- result = []
- for key in keys:
- if key in dict:
- result += dict[key]
- return result
-
-
-def has_disable(commands):
- for command in commands:
- if command["name"] == "disable":
- return True
- return False
-
-
-def format_include(header):
- return "\"" + header + "\"" if header[0] not in "<\"" else header
-
-
-def read_protocol_file(file_name, json_api):
- input_file = open(file_name, "r")
- json_string = input_file.read()
- input_file.close()
- parsed_json = json.loads(json_string)
- version = parsed_json["version"]["major"] + "." + parsed_json["version"]["minor"]
- domains = []
- for domain in parsed_json["domains"]:
- domains.append(domain["domain"])
- domain["version"] = version
- json_api["domains"] += parsed_json["domains"]
- return domains
-
-
-class Protocol(object):
- def __init__(self):
- self.json_api = {}
- self.generate_domains = []
- self.imported_domains = []
-
-
-def main():
- jinja_dir, config_file, config = read_config()
-
- protocol = Protocol()
- protocol.json_api = {"domains": []}
- protocol.generate_domains = read_protocol_file(config.protocol.path, protocol.json_api)
- protocol.imported_domains = read_protocol_file(config.imported.path, protocol.json_api) if config.imported else []
- patch_full_qualified_refs(protocol)
- calculate_exports(protocol)
- create_type_definitions(protocol, "::".join(config.imported.namespace) if config.imported else "")
-
- if not config.exported:
- for domain_json in protocol.json_api["domains"]:
- if domain_json["has_exports"] and domain_json["domain"] in protocol.generate_domains:
- sys.stderr.write("Domain %s is exported, but config is missing export entry\n\n" % domain_json["domain"])
- exit(1)
-
- if not os.path.exists(config.protocol.output):
- os.mkdir(config.protocol.output)
- if protocol.json_api["has_exports"] and not os.path.exists(config.exported.output):
- os.mkdir(config.exported.output)
- jinja_env = initialize_jinja_env(jinja_dir, config.protocol.output)
-
- inputs = []
- inputs.append(__file__)
- inputs.append(config_file)
- inputs.append(config.protocol.path)
- if config.imported:
- inputs.append(config.imported.path)
- templates_dir = os.path.join(module_path, "templates")
- inputs.append(os.path.join(templates_dir, "TypeBuilder_h.template"))
- inputs.append(os.path.join(templates_dir, "TypeBuilder_cpp.template"))
- inputs.append(os.path.join(templates_dir, "Exported_h.template"))
- inputs.append(os.path.join(templates_dir, "Imported_h.template"))
-
- h_template = jinja_env.get_template("templates/TypeBuilder_h.template")
- cpp_template = jinja_env.get_template("templates/TypeBuilder_cpp.template")
- exported_template = jinja_env.get_template("templates/Exported_h.template")
- imported_template = jinja_env.get_template("templates/Imported_h.template")
-
- outputs = dict()
-
- for domain in protocol.json_api["domains"]:
- class_name = domain["domain"]
- template_context = {
- "config": config,
- "domain": domain,
- "join_arrays": join_arrays,
- "resolve_type": functools.partial(resolve_type, protocol),
- "type_definition": functools.partial(type_definition, protocol),
- "has_disable": has_disable,
- "format_include": format_include,
- }
-
- if domain["domain"] in protocol.generate_domains:
- outputs[os.path.join(config.protocol.output, class_name + ".h")] = h_template.render(template_context)
- outputs[os.path.join(config.protocol.output, class_name + ".cpp")] = cpp_template.render(template_context)
- if domain["has_exports"]:
- outputs[os.path.join(config.exported.output, class_name + ".h")] = exported_template.render(template_context)
- if domain["domain"] in protocol.imported_domains and domain["has_exports"]:
- outputs[os.path.join(config.protocol.output, class_name + ".h")] = imported_template.render(template_context)
-
- if config.lib:
- template_context = {
- "config": config,
- "format_include": format_include,
- }
-
- lib_templates_dir = os.path.join(module_path, "lib")
- # Note these should be sorted in the right order.
- # TODO(dgozman): sort them programmatically based on commented includes.
- lib_h_templates = [
- "Collections_h.template",
- "ErrorSupport_h.template",
- "Values_h.template",
- "Object_h.template",
- "ValueConversions_h.template",
- "Maybe_h.template",
- "Array_h.template",
- "BackendCallback_h.template",
- "DispatcherBase_h.template",
- "Parser_h.template",
- ]
-
- lib_cpp_templates = [
- "Protocol_cpp.template",
- "ErrorSupport_cpp.template",
- "Values_cpp.template",
- "Object_cpp.template",
- "DispatcherBase_cpp.template",
- "Parser_cpp.template",
- ]
-
- forward_h_templates = [
- "Forward_h.template",
- "Allocator_h.template",
- "FrontendChannel_h.template",
- ]
-
- def generate_lib_file(file_name, template_files):
- parts = []
- for template_file in template_files:
- inputs.append(os.path.join(lib_templates_dir, template_file))
- template = jinja_env.get_template("lib/" + template_file)
- parts.append(template.render(template_context))
- outputs[file_name] = "\n\n".join(parts)
-
- generate_lib_file(os.path.join(config.lib.output, "Forward.h"), forward_h_templates)
- generate_lib_file(os.path.join(config.lib.output, "Protocol.h"), lib_h_templates)
- generate_lib_file(os.path.join(config.lib.output, "Protocol.cpp"), lib_cpp_templates)
-
- # Make gyp / make generatos happy, otherwise make rebuilds world.
- inputs_ts = max(map(os.path.getmtime, inputs))
- up_to_date = True
- for output_file in outputs.iterkeys():
- if not os.path.exists(output_file) or os.path.getmtime(output_file) < inputs_ts:
- up_to_date = False
- break
- if up_to_date:
- sys.exit()
-
- for file_name, content in outputs.iteritems():
- out_file = open(file_name, "w")
- out_file.write(content)
- out_file.close()
-
-
-main()
diff --git a/ConcatenateProtocols.py b/ConcatenateProtocols.py
deleted file mode 100755
index a7cbc99..0000000
--- a/ConcatenateProtocols.py
+++ /dev/null
@@ -1,39 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-import os.path
-import sys
-
-try:
- import json
-except ImportError:
- import simplejson as json
-
-
-def main(argv):
- if len(argv) < 1:
- sys.stderr.write("Usage: %s <protocol-1> [<protocol-2> [, <protocol-3>...]] <output-file>\n" % sys.argv[0])
- return 1
-
- domains = []
- version = None
- for protocol in argv[:-1]:
- file_name = os.path.normpath(protocol)
- if not os.path.isfile(file_name):
- sys.stderr.write("Cannot find %s\n" % file_name)
- return 1
- input_file = open(file_name, "r")
- json_string = input_file.read()
- parsed_json = json.loads(json_string)
- domains += parsed_json["domains"]
- version = parsed_json["version"]
-
- output_file = open(argv[-1], "w")
- json.dump({"version": version, "domains": domains}, output_file, indent=4, sort_keys=False, separators=(',', ': '))
- output_file.close()
-
-
-if __name__ == '__main__':
- sys.exit(main(sys.argv[1:]))
diff --git a/OWNERS b/OWNERS
deleted file mode 100644
index c34ad77..0000000
--- a/OWNERS
+++ /dev/null
@@ -1,5 +0,0 @@
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
diff --git a/inspector_protocol.gni b/inspector_protocol.gni
deleted file mode 100644
index 4b161a0..0000000
--- a/inspector_protocol.gni
+++ /dev/null
@@ -1,82 +0,0 @@
-# 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.
-
-# This template will generate inspector protocol source code. The code will
-# not be compiled, use get_target_outputs(<name>) to compile them.
-#
-# Inputs
-#
-# config_file (required)
-# Path to json file specifying inspector protocol configuration.
-#
-# out_dir (required)
-# Path to put the generated files in. It must be inside output or
-# generated file directory.
-#
-# outputs (required)
-# Files generated. Relative to out_dir.
-#
-# inputs (optional)
-# Extra inputs specified by the config file.
-template("inspector_protocol_generate") {
- assert(defined(invoker.config_file))
- assert(defined(invoker.out_dir))
- assert(defined(invoker.outputs))
-
- inspector_protocol_dir =
- "//third_party/WebKit/Source/platform/inspector_protocol"
-
- action(target_name) {
- script = "$inspector_protocol_dir/CodeGenerator.py"
-
- inputs = [
- invoker.config_file,
- "$inspector_protocol_dir/lib/Allocator_h.template",
- "$inspector_protocol_dir/lib/Array_h.template",
- "$inspector_protocol_dir/lib/BackendCallback_h.template",
- "$inspector_protocol_dir/lib/Collections_h.template",
- "$inspector_protocol_dir/lib/DispatcherBase_cpp.template",
- "$inspector_protocol_dir/lib/DispatcherBase_h.template",
- "$inspector_protocol_dir/lib/ErrorSupport_cpp.template",
- "$inspector_protocol_dir/lib/ErrorSupport_h.template",
- "$inspector_protocol_dir/lib/Forward_h.template",
- "$inspector_protocol_dir/lib/FrontendChannel_h.template",
- "$inspector_protocol_dir/lib/Maybe_h.template",
- "$inspector_protocol_dir/lib/Object_cpp.template",
- "$inspector_protocol_dir/lib/Object_h.template",
- "$inspector_protocol_dir/lib/Parser_cpp.template",
- "$inspector_protocol_dir/lib/Parser_h.template",
- "$inspector_protocol_dir/lib/Protocol_cpp.template",
- "$inspector_protocol_dir/lib/ValueConversions_h.template",
- "$inspector_protocol_dir/lib/Values_cpp.template",
- "$inspector_protocol_dir/lib/Values_h.template",
- "$inspector_protocol_dir/templates/Exported_h.template",
- "$inspector_protocol_dir/templates/Imported_h.template",
- "$inspector_protocol_dir/templates/TypeBuilder_cpp.template",
- "$inspector_protocol_dir/templates/TypeBuilder_h.template",
- ]
- if (defined(invoker.inputs)) {
- inputs += invoker.inputs
- }
-
- args = [
- "--jinja_dir",
- rebase_path("//third_party/", root_build_dir), # jinja is in chromium's third_party
- "--output_base",
- rebase_path(invoker.out_dir, root_build_dir),
- "--config",
- rebase_path(invoker.config_file, root_build_dir),
- ]
-
- outputs = get_path_info(rebase_path(invoker.outputs, ".", invoker.out_dir),
- "abspath")
-
- forward_variables_from(invoker,
- [
- "visibility",
- "deps",
- "public_deps",
- ])
- }
-}
diff --git a/inspector_protocol.gypi b/inspector_protocol.gypi
deleted file mode 100644
index aa43821..0000000
--- a/inspector_protocol.gypi
+++ /dev/null
@@ -1,36 +0,0 @@
-# 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.
-
-# Note: do not remove this file, it's used by v8's gyp.
-# It will be moved out from platform/ soon.
-{
- 'variables': {
- 'inspector_protocol_files': [
- 'lib/Allocator_h.template',
- 'lib/Array_h.template',
- 'lib/BackendCallback_h.template',
- 'lib/Collections_h.template',
- 'lib/DispatcherBase_cpp.template',
- 'lib/DispatcherBase_h.template',
- 'lib/ErrorSupport_cpp.template',
- 'lib/ErrorSupport_h.template',
- 'lib/Forward_h.template',
- 'lib/FrontendChannel_h.template',
- 'lib/Maybe_h.template',
- 'lib/Object_cpp.template',
- 'lib/Object_h.template',
- 'lib/Parser_cpp.template',
- 'lib/Parser_h.template',
- 'lib/Protocol_cpp.template',
- 'lib/ValueConversions_h.template',
- 'lib/Values_cpp.template',
- 'lib/Values_h.template',
- 'templates/Exported_h.template',
- 'templates/Imported_h.template',
- 'templates/TypeBuilder_cpp.template',
- 'templates/TypeBuilder_h.template',
- 'CodeGenerator.py',
- ]
- }
-}
diff --git a/lib/Allocator_h.template b/lib/Allocator_h.template
deleted file mode 100644
index 8f8109d..0000000
--- a/lib/Allocator_h.template
+++ /dev/null
@@ -1,30 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Allocator_h
-#define {{"_".join(config.protocol.namespace)}}_Allocator_h
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-enum NotNullTagEnum { NotNullLiteral };
-
-#define PROTOCOL_DISALLOW_NEW() \
- private: \
- void* operator new(size_t) = delete; \
- void* operator new(size_t, NotNullTagEnum, void*) = delete; \
- void* operator new(size_t, void*) = delete; \
- public:
-
-#define PROTOCOL_DISALLOW_COPY(ClassName) \
- private: \
- ClassName(const ClassName&) = delete; \
- ClassName& operator=(const ClassName&) = delete
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Allocator_h)
diff --git a/lib/Array_h.template b/lib/Array_h.template
deleted file mode 100644
index 9555e30..0000000
--- a/lib/Array_h.template
+++ /dev/null
@@ -1,136 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Array_h
-#define {{"_".join(config.protocol.namespace)}}_Array_h
-
-//#include "ErrorSupport.h"
-//#include "Forward.h"
-//#include "ValueConversions.h"
-//#include "Values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-template<typename T>
-class Array {
-public:
- static std::unique_ptr<Array<T>> create()
- {
- return wrapUnique(new Array<T>());
- }
-
- static std::unique_ptr<Array<T>> parse(protocol::Value* value, ErrorSupport* errors)
- {
- protocol::ListValue* array = ListValue::cast(value);
- if (!array) {
- errors->addError("array expected");
- return nullptr;
- }
- std::unique_ptr<Array<T>> result(new Array<T>());
- errors->push();
- for (size_t i = 0; i < array->size(); ++i) {
- errors->setName(StringUtil::fromInteger(i));
- std::unique_ptr<T> item = ValueConversions<T>::parse(array->at(i), errors);
- result->m_vector.push_back(std::move(item));
- }
- errors->pop();
- if (errors->hasErrors())
- return nullptr;
- return result;
- }
-
- void addItem(std::unique_ptr<T> value)
- {
- m_vector.push_back(std::move(value));
- }
-
- size_t length()
- {
- return m_vector.size();
- }
-
- T* get(size_t index)
- {
- return m_vector[index].get();
- }
-
- std::unique_ptr<protocol::ListValue> serialize()
- {
- std::unique_ptr<protocol::ListValue> result = ListValue::create();
- for (auto& item : m_vector)
- result->pushValue(ValueConversions<T>::serialize(item));
- return result;
- }
-
-private:
- std::vector<std::unique_ptr<T>> m_vector;
-};
-
-template<typename T>
-class ArrayBase {
-public:
- static std::unique_ptr<Array<T>> create()
- {
- return wrapUnique(new Array<T>());
- }
-
- static std::unique_ptr<Array<T>> parse(protocol::Value* value, ErrorSupport* errors)
- {
- protocol::ListValue* array = ListValue::cast(value);
- if (!array) {
- errors->addError("array expected");
- return nullptr;
- }
- errors->push();
- std::unique_ptr<Array<T>> result(new Array<T>());
- for (size_t i = 0; i < array->size(); ++i) {
- errors->setName(StringUtil::fromInteger(i));
- T item = ValueConversions<T>::parse(array->at(i), errors);
- result->m_vector.push_back(item);
- }
- errors->pop();
- if (errors->hasErrors())
- return nullptr;
- return result;
- }
-
- void addItem(const T& value)
- {
- m_vector.push_back(value);
- }
-
- size_t length()
- {
- return m_vector.size();
- }
-
- T get(size_t index)
- {
- return m_vector[index];
- }
-
- std::unique_ptr<protocol::ListValue> serialize()
- {
- std::unique_ptr<protocol::ListValue> result = ListValue::create();
- for (auto& item : m_vector)
- result->pushValue(ValueConversions<T>::serialize(item));
- return result;
- }
-
-private:
- std::vector<T> m_vector;
-};
-
-template<> class Array<String> : public ArrayBase<String> {};
-template<> class Array<int> : public ArrayBase<int> {};
-template<> class Array<double> : public ArrayBase<double> {};
-template<> class Array<bool> : public ArrayBase<bool> {};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Array_h)
diff --git a/lib/BackendCallback_h.template b/lib/BackendCallback_h.template
deleted file mode 100644
index 3c8fc15..0000000
--- a/lib/BackendCallback_h.template
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright (c) 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_BackendCallback_h
-#define {{"_".join(config.protocol.namespace)}}_BackendCallback_h
-
-//#include "Forward.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class {{config.lib.export_macro}} BackendCallback {
-public:
- virtual ~BackendCallback() { }
- virtual void sendFailure(const ErrorString&) = 0;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_BackendCallback_h)
diff --git a/lib/Collections_h.template b/lib/Collections_h.template
deleted file mode 100644
index 3f76028..0000000
--- a/lib/Collections_h.template
+++ /dev/null
@@ -1,43 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Collections_h
-#define {{"_".join(config.protocol.namespace)}}_Collections_h
-
-#include "{{config.protocol.package}}/Forward.h"
-#include <cstddef>
-
-#if defined(__APPLE__) && !defined(_LIBCPP_VERSION)
-#include <map>
-#include <set>
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-template <class Key, class T> using HashMap = std::map<Key, T>;
-template <class Key> using HashSet = std::set<Key>;
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#else
-#include <unordered_map>
-#include <unordered_set>
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-template <class Key, class T> using HashMap = std::unordered_map<Key, T>;
-template <class Key> using HashSet = std::unordered_set<Key>;
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // defined(__APPLE__) && !defined(_LIBCPP_VERSION)
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Collections_h)
diff --git a/lib/DispatcherBase_cpp.template b/lib/DispatcherBase_cpp.template
deleted file mode 100644
index 76f77aa..0000000
--- a/lib/DispatcherBase_cpp.template
+++ /dev/null
@@ -1,173 +0,0 @@
-// 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.
-
-//#include "DispatcherBase.h"
-//#include "Parser.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-// static
-const char DispatcherBase::kInvalidRequest[] = "Invalid request";
-
-DispatcherBase::WeakPtr::WeakPtr(DispatcherBase* dispatcher) : m_dispatcher(dispatcher) { }
-
-DispatcherBase::WeakPtr::~WeakPtr()
-{
- if (m_dispatcher)
- m_dispatcher->m_weakPtrs.erase(this);
-}
-
-DispatcherBase::Callback::Callback(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId)
- : m_backendImpl(std::move(backendImpl))
- , m_callId(callId) { }
-
-DispatcherBase::Callback::~Callback() = default;
-
-void DispatcherBase::Callback::dispose()
-{
- m_backendImpl = nullptr;
-}
-
-void DispatcherBase::Callback::sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const ErrorString& invocationError)
-{
- if (!m_backendImpl || !m_backendImpl->get())
- return;
- m_backendImpl->get()->sendResponse(m_callId, invocationError, nullptr, std::move(partialMessage));
- m_backendImpl = nullptr;
-}
-
-DispatcherBase::DispatcherBase(FrontendChannel* frontendChannel)
- : m_frontendChannel(frontendChannel) { }
-
-DispatcherBase::~DispatcherBase()
-{
- clearFrontend();
-}
-
-// static
-bool DispatcherBase::getCommandName(const String& message, String* result)
-{
- std::unique_ptr<protocol::Value> value = parseJSON(message);
- if (!value)
- return false;
-
- protocol::DictionaryValue* object = DictionaryValue::cast(value.get());
- if (!object)
- return false;
-
- if (!object->getString("method", result))
- return false;
-
- return true;
-}
-
-void DispatcherBase::sendResponse(int callId, const ErrorString& invocationError, ErrorSupport* errors, std::unique_ptr<protocol::DictionaryValue> result)
-{
- if (invocationError.length() || (errors && errors->hasErrors())) {
- reportProtocolError(callId, ServerError, invocationError, errors);
- return;
- }
-
- std::unique_ptr<protocol::DictionaryValue> responseMessage = DictionaryValue::create();
- responseMessage->setInteger("id", callId);
- responseMessage->setObject("result", std::move(result));
- if (m_frontendChannel)
- m_frontendChannel->sendProtocolResponse(callId, responseMessage->toJSONString());
-}
-
-void DispatcherBase::sendResponse(int callId, const ErrorString& invocationError, std::unique_ptr<protocol::DictionaryValue> result)
-{
- sendResponse(callId, invocationError, nullptr, std::move(result));
-}
-
-void DispatcherBase::sendResponse(int callId, const ErrorString& invocationError)
-{
- sendResponse(callId, invocationError, nullptr, DictionaryValue::create());
-}
-
-static void reportProtocolErrorTo(FrontendChannel* frontendChannel, int callId, DispatcherBase::CommonErrorCode code, const String& errorMessage, ErrorSupport* errors)
-{
- if (!frontendChannel)
- return;
- std::unique_ptr<protocol::DictionaryValue> error = DictionaryValue::create();
- error->setInteger("code", code);
- error->setString("message", errorMessage);
- DCHECK(error);
- if (errors && errors->hasErrors())
- error->setString("data", errors->errors());
- std::unique_ptr<protocol::DictionaryValue> message = DictionaryValue::create();
- message->setObject("error", std::move(error));
- message->setInteger("id", callId);
- frontendChannel->sendProtocolResponse(callId, message->toJSONString());
-}
-
-void DispatcherBase::reportProtocolError(int callId, CommonErrorCode code, const String& errorMessage, ErrorSupport* errors)
-{
- reportProtocolErrorTo(m_frontendChannel, callId, code, errorMessage, errors);
-}
-
-void DispatcherBase::clearFrontend()
-{
- m_frontendChannel = nullptr;
- for (auto& weak : m_weakPtrs)
- weak->dispose();
- m_weakPtrs.clear();
-}
-
-std::unique_ptr<DispatcherBase::WeakPtr> DispatcherBase::weakPtr()
-{
- std::unique_ptr<DispatcherBase::WeakPtr> weak(new DispatcherBase::WeakPtr(this));
- m_weakPtrs.insert(weak.get());
- return weak;
-}
-
-UberDispatcher::UberDispatcher(FrontendChannel* frontendChannel)
- : m_frontendChannel(frontendChannel) { }
-
-void UberDispatcher::registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase> dispatcher)
-{
- m_dispatchers[name] = std::move(dispatcher);
-}
-
-void UberDispatcher::dispatch(std::unique_ptr<Value> parsedMessage)
-{
- if (!parsedMessage)
- return;
- std::unique_ptr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(std::move(parsedMessage));
- if (!messageObject)
- return;
-
- int callId = 0;
- protocol::Value* callIdValue = messageObject->get("id");
- bool success = callIdValue && callIdValue->asInteger(&callId);
- if (!success)
- return;
-
- protocol::Value* methodValue = messageObject->get("method");
- String method;
- success = methodValue && methodValue->asString(&method);
- if (!success)
- return;
-
- size_t dotIndex = method.find(".");
- if (dotIndex == StringUtil::kNotFound) {
- reportProtocolErrorTo(m_frontendChannel, callId, DispatcherBase::MethodNotFound, "'" + method + "' wasn't found", nullptr);
- return;
- }
- String domain = StringUtil::substring(method, 0, dotIndex);
- auto it = m_dispatchers.find(domain);
- if (it == m_dispatchers.end()) {
- reportProtocolErrorTo(m_frontendChannel, callId, DispatcherBase::MethodNotFound, "'" + method + "' wasn't found", nullptr);
- return;
- }
- it->second->dispatch(callId, method, std::move(messageObject));
-}
-
-UberDispatcher::~UberDispatcher() = default;
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/lib/DispatcherBase_h.template b/lib/DispatcherBase_h.template
deleted file mode 100644
index 17fd870..0000000
--- a/lib/DispatcherBase_h.template
+++ /dev/null
@@ -1,97 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_DispatcherBase_h
-#define {{"_".join(config.protocol.namespace)}}_DispatcherBase_h
-
-//#include "BackendCallback.h"
-//#include "Collections.h"
-//#include "ErrorSupport.h"
-//#include "Forward.h"
-//#include "Values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class WeakPtr;
-
-class {{config.lib.export_macro}} DispatcherBase {
- PROTOCOL_DISALLOW_COPY(DispatcherBase);
-public:
- static const char kInvalidRequest[];
- class {{config.lib.export_macro}} WeakPtr {
- public:
- explicit WeakPtr(DispatcherBase*);
- ~WeakPtr();
- DispatcherBase* get() { return m_dispatcher; }
- void dispose() { m_dispatcher = nullptr; }
-
- private:
- DispatcherBase* m_dispatcher;
- };
-
- class {{config.lib.export_macro}} Callback : public protocol::BackendCallback {
- public:
- Callback(std::unique_ptr<WeakPtr> backendImpl, int callId);
- virtual ~Callback();
- void dispose();
-
- protected:
- void sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const ErrorString& invocationError);
-
- private:
- std::unique_ptr<WeakPtr> m_backendImpl;
- int m_callId;
- };
-
- explicit DispatcherBase(FrontendChannel*);
- virtual ~DispatcherBase();
-
- enum CommonErrorCode {
- ParseError = -32700,
- InvalidRequest = -32600,
- MethodNotFound = -32601,
- InvalidParams = -32602,
- InternalError = -32603,
- ServerError = -32000,
- };
-
- static bool getCommandName(const String& message, String* result);
-
- virtual void dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) = 0;
-
- void sendResponse(int callId, const ErrorString&, ErrorSupport*, std::unique_ptr<protocol::DictionaryValue> result);
- void sendResponse(int callId, const ErrorString&, std::unique_ptr<protocol::DictionaryValue> result);
- void sendResponse(int callId, const ErrorString&);
-
- void reportProtocolError(int callId, CommonErrorCode, const String& errorMessage, ErrorSupport* errors);
- void clearFrontend();
-
- std::unique_ptr<WeakPtr> weakPtr();
-
-private:
- FrontendChannel* m_frontendChannel;
- protocol::HashSet<WeakPtr*> m_weakPtrs;
-};
-
-class {{config.lib.export_macro}} UberDispatcher {
- PROTOCOL_DISALLOW_COPY(UberDispatcher);
-public:
- explicit UberDispatcher(FrontendChannel*);
- void registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase>);
- void dispatch(std::unique_ptr<Value> message);
- FrontendChannel* channel() { return m_frontendChannel; }
- virtual ~UberDispatcher();
-
-private:
- FrontendChannel* m_frontendChannel;
- protocol::HashMap<String, std::unique_ptr<protocol::DispatcherBase>> m_dispatchers;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_DispatcherBase_h)
diff --git a/lib/ErrorSupport_cpp.template b/lib/ErrorSupport_cpp.template
deleted file mode 100644
index 34593ec..0000000
--- a/lib/ErrorSupport_cpp.template
+++ /dev/null
@@ -1,70 +0,0 @@
-// 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.
-
-//#include "ErrorSupport.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-ErrorSupport::ErrorSupport() : m_errorString(nullptr) { }
-ErrorSupport::ErrorSupport(String* errorString) : m_errorString(errorString) { }
-ErrorSupport::~ErrorSupport()
-{
- if (m_errorString && hasErrors()) {
- StringBuilder builder;
- builder.append("Internal error(s): ");
- builder.append(errors());
- *m_errorString = builder.toString();
- }
-}
-
-void ErrorSupport::setName(const String& name)
-{
- DCHECK(m_path.size());
- m_path[m_path.size() - 1] = name;
-}
-
-void ErrorSupport::push()
-{
- m_path.push_back(String());
-}
-
-void ErrorSupport::pop()
-{
- m_path.pop_back();
-}
-
-void ErrorSupport::addError(const String& error)
-{
- StringBuilder builder;
- for (size_t i = 0; i < m_path.size(); ++i) {
- if (i)
- builder.append('.');
- builder.append(m_path[i]);
- }
- builder.append(": ");
- builder.append(error);
- m_errors.push_back(builder.toString());
-}
-
-bool ErrorSupport::hasErrors()
-{
- return m_errors.size();
-}
-
-String ErrorSupport::errors()
-{
- StringBuilder builder;
- for (size_t i = 0; i < m_errors.size(); ++i) {
- if (i)
- builder.append("; ");
- builder.append(m_errors[i]);
- }
- return builder.toString();
-}
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/lib/ErrorSupport_h.template b/lib/ErrorSupport_h.template
deleted file mode 100644
index 9d2a192..0000000
--- a/lib/ErrorSupport_h.template
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_ErrorSupport_h
-#define {{"_".join(config.protocol.namespace)}}_ErrorSupport_h
-
-//#include "Forward.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class {{config.lib.export_macro}} ErrorSupport {
-public:
- ErrorSupport();
- ErrorSupport(String* errorString);
- ~ErrorSupport();
-
- void push();
- void setName(const String&);
- void pop();
- void addError(const String&);
- bool hasErrors();
- String errors();
-
-private:
- std::vector<String> m_path;
- std::vector<String> m_errors;
- String* m_errorString;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_ErrorSupport_h)
diff --git a/lib/Forward_h.template b/lib/Forward_h.template
deleted file mode 100644
index 2ad3897..0000000
--- a/lib/Forward_h.template
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Forward_h
-#define {{"_".join(config.protocol.namespace)}}_Forward_h
-
-{% if config.lib.export_header %}
-#include {{format_include(config.lib.export_header)}}
-{% endif %}
-#include {{format_include(config.lib.platform_header)}}
-#include {{format_include(config.lib.string_header)}}
-
-#include <vector>
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-template<typename T> class Array;
-class DictionaryValue;
-using ErrorString = String;
-class ErrorSupport;
-class FundamentalValue;
-class ListValue;
-template<typename T> class Maybe;
-class Object;
-class SerializedValue;
-class StringValue;
-class UberDispatcher;
-class Value;
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Forward_h)
diff --git a/lib/FrontendChannel_h.template b/lib/FrontendChannel_h.template
deleted file mode 100644
index 8b653b5..0000000
--- a/lib/FrontendChannel_h.template
+++ /dev/null
@@ -1,24 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_FrontendChannel_h
-#define {{"_".join(config.protocol.namespace)}}_FrontendChannel_h
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class {{config.lib.export_macro}} FrontendChannel {
-public:
- virtual ~FrontendChannel() { }
- virtual void sendProtocolResponse(int callId, const String& message) = 0;
- virtual void sendProtocolNotification(const String& message) = 0;
- virtual void flushProtocolNotifications() = 0;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_FrontendChannel_h)
diff --git a/lib/Maybe_h.template b/lib/Maybe_h.template
deleted file mode 100644
index 2096572..0000000
--- a/lib/Maybe_h.template
+++ /dev/null
@@ -1,80 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Maybe_h
-#define {{"_".join(config.protocol.namespace)}}_Maybe_h
-
-//#include "Forward.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-template<typename T>
-class Maybe {
-public:
- Maybe() : m_value() { }
- Maybe(std::unique_ptr<T> value) : m_value(std::move(value)) { }
- void operator=(std::unique_ptr<T> value) { m_value = std::move(value); }
- T* fromJust() const { DCHECK(m_value); return m_value.get(); }
- T* fromMaybe(T* defaultValue) const { return m_value ? m_value.get() : defaultValue; }
- bool isJust() const { return !!m_value; }
- std::unique_ptr<T> takeJust() { DCHECK(m_value); return m_value.release(); }
-private:
- std::unique_ptr<T> m_value;
-};
-
-template<typename T>
-class MaybeBase {
-public:
- MaybeBase() : m_isJust(false) { }
- MaybeBase(T value) : m_isJust(true), m_value(value) { }
- void operator=(T value) { m_value = value; m_isJust = true; }
- T fromJust() const { DCHECK(m_isJust); return m_value; }
- T fromMaybe(const T& defaultValue) const { return m_isJust ? m_value : defaultValue; }
- bool isJust() const { return m_isJust; }
- T takeJust() { DCHECK(m_isJust); return m_value; }
-
-protected:
- bool m_isJust;
- T m_value;
-};
-
-template<>
-class Maybe<bool> : public MaybeBase<bool> {
-public:
- Maybe() { }
- Maybe(bool value) : MaybeBase(value) { }
- using MaybeBase::operator=;
-};
-
-template<>
-class Maybe<int> : public MaybeBase<int> {
-public:
- Maybe() { }
- Maybe(int value) : MaybeBase(value) { }
- using MaybeBase::operator=;
-};
-
-template<>
-class Maybe<double> : public MaybeBase<double> {
-public:
- Maybe() { }
- Maybe(double value) : MaybeBase(value) { }
- using MaybeBase::operator=;
-};
-
-template<>
-class Maybe<String> : public MaybeBase<String> {
-public:
- Maybe() { }
- Maybe(const String& value) : MaybeBase(value) { }
- using MaybeBase::operator=;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Maybe_h)
diff --git a/lib/Object_cpp.template b/lib/Object_cpp.template
deleted file mode 100644
index e3f18c3..0000000
--- a/lib/Object_cpp.template
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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.
-
-//#include "Object.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-std::unique_ptr<Object> Object::parse(protocol::Value* value, ErrorSupport* errors)
-{
- protocol::DictionaryValue* object = DictionaryValue::cast(value);
- if (!object) {
- errors->addError("object expected");
- return nullptr;
- }
- return wrapUnique(new Object(wrapUnique(static_cast<DictionaryValue*>(object->clone().release()))));
-}
-
-std::unique_ptr<protocol::DictionaryValue> Object::serialize() const
-{
- return DictionaryValue::cast(m_object->clone());
-}
-
-std::unique_ptr<Object> Object::clone() const
-{
- return wrapUnique(new Object(DictionaryValue::cast(m_object->clone())));
-}
-
-Object::Object(std::unique_ptr<protocol::DictionaryValue> object) : m_object(std::move(object)) { }
-
-Object::~Object() { }
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/lib/Object_h.template b/lib/Object_h.template
deleted file mode 100644
index 4ccd88b..0000000
--- a/lib/Object_h.template
+++ /dev/null
@@ -1,32 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Object_h
-#define {{"_".join(config.protocol.namespace)}}_Object_h
-
-//#include "ErrorSupport.h"
-//#include "Forward.h"
-//#include "Values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class {{config.lib.export_macro}} Object {
-public:
- static std::unique_ptr<Object> parse(protocol::Value*, ErrorSupport*);
- ~Object();
-
- std::unique_ptr<protocol::DictionaryValue> serialize() const;
- std::unique_ptr<Object> clone() const;
-private:
- explicit Object(std::unique_ptr<protocol::DictionaryValue>);
- std::unique_ptr<protocol::DictionaryValue> m_object;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Object_h)
diff --git a/lib/Parser_cpp.template b/lib/Parser_cpp.template
deleted file mode 100644
index a103b82..0000000
--- a/lib/Parser_cpp.template
+++ /dev/null
@@ -1,553 +0,0 @@
-// 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.
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-namespace {
-
-const int stackLimit = 1000;
-
-enum Token {
- ObjectBegin,
- ObjectEnd,
- ArrayBegin,
- ArrayEnd,
- StringLiteral,
- Number,
- BoolTrue,
- BoolFalse,
- NullToken,
- ListSeparator,
- ObjectPairSeparator,
- InvalidToken,
-};
-
-const char* const nullString = "null";
-const char* const trueString = "true";
-const char* const falseString = "false";
-
-bool isASCII(uint16_t c)
-{
- return !(c & ~0x7F);
-}
-
-bool isSpaceOrNewLine(uint16_t c)
-{
- return isASCII(c) && c <= ' ' && (c == ' ' || (c <= 0xD && c >= 0x9));
-}
-
-double charactersToDouble(const uint16_t* characters, size_t length, bool* ok)
-{
- std::vector<char> buffer;
- buffer.reserve(length + 1);
- for (size_t i = 0; i < length; ++i) {
- if (!isASCII(characters[i])) {
- *ok = false;
- return 0;
- }
- buffer.push_back(static_cast<char>(characters[i]));
- }
- buffer.push_back('\0');
- char* endptr;
- double result = std::strtod(buffer.data(), &endptr);
- *ok = !(*endptr);
- return result;
-}
-
-double charactersToDouble(const uint8_t* characters, size_t length, bool* ok)
-{
- std::string buffer(reinterpret_cast<const char*>(characters), length);
- char* endptr;
- double result = std::strtod(buffer.data(), &endptr);
- *ok = !(*endptr);
- return result;
-}
-
-template<typename Char>
-bool parseConstToken(const Char* start, const Char* end, const Char** tokenEnd, const char* token)
-{
- while (start < end && *token != '\0' && *start++ == *token++) { }
- if (*token != '\0')
- return false;
- *tokenEnd = start;
- return true;
-}
-
-template<typename Char>
-bool readInt(const Char* start, const Char* end, const Char** tokenEnd, bool canHaveLeadingZeros)
-{
- if (start == end)
- return false;
- bool haveLeadingZero = '0' == *start;
- int length = 0;
- while (start < end && '0' <= *start && *start <= '9') {
- ++start;
- ++length;
- }
- if (!length)
- return false;
- if (!canHaveLeadingZeros && length > 1 && haveLeadingZero)
- return false;
- *tokenEnd = start;
- return true;
-}
-
-template<typename Char>
-bool parseNumberToken(const Char* start, const Char* end, const Char** tokenEnd)
-{
- // We just grab the number here. We validate the size in DecodeNumber.
- // According to RFC4627, a valid number is: [minus] int [frac] [exp]
- if (start == end)
- return false;
- Char c = *start;
- if ('-' == c)
- ++start;
-
- if (!readInt(start, end, &start, false))
- return false;
- if (start == end) {
- *tokenEnd = start;
- return true;
- }
-
- // Optional fraction part
- c = *start;
- if ('.' == c) {
- ++start;
- if (!readInt(start, end, &start, true))
- return false;
- if (start == end) {
- *tokenEnd = start;
- return true;
- }
- c = *start;
- }
-
- // Optional exponent part
- if ('e' == c || 'E' == c) {
- ++start;
- if (start == end)
- return false;
- c = *start;
- if ('-' == c || '+' == c) {
- ++start;
- if (start == end)
- return false;
- }
- if (!readInt(start, end, &start, true))
- return false;
- }
-
- *tokenEnd = start;
- return true;
-}
-
-template<typename Char>
-bool readHexDigits(const Char* start, const Char* end, const Char** tokenEnd, int digits)
-{
- if (end - start < digits)
- return false;
- for (int i = 0; i < digits; ++i) {
- Char c = *start++;
- if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')))
- return false;
- }
- *tokenEnd = start;
- return true;
-}
-
-template<typename Char>
-bool parseStringToken(const Char* start, const Char* end, const Char** tokenEnd)
-{
- while (start < end) {
- Char c = *start++;
- if ('\\' == c) {
- if (start == end)
- return false;
- c = *start++;
- // Make sure the escaped char is valid.
- switch (c) {
- case 'x':
- if (!readHexDigits(start, end, &start, 2))
- return false;
- break;
- case 'u':
- if (!readHexDigits(start, end, &start, 4))
- return false;
- break;
- case '\\':
- case '/':
- case 'b':
- case 'f':
- case 'n':
- case 'r':
- case 't':
- case 'v':
- case '"':
- break;
- default:
- return false;
- }
- } else if ('"' == c) {
- *tokenEnd = start;
- return true;
- }
- }
- return false;
-}
-
-template<typename Char>
-bool skipComment(const Char* start, const Char* end, const Char** commentEnd)
-{
- if (start == end)
- return false;
-
- if (*start != '/' || start + 1 >= end)
- return false;
- ++start;
-
- if (*start == '/') {
- // Single line comment, read to newline.
- for (++start; start < end; ++start) {
- if (*start == '\n' || *start == '\r') {
- *commentEnd = start + 1;
- return true;
- }
- }
- *commentEnd = end;
- // Comment reaches end-of-input, which is fine.
- return true;
- }
-
- if (*start == '*') {
- Char previous = '\0';
- // Block comment, read until end marker.
- for (++start; start < end; previous = *start++) {
- if (previous == '*' && *start == '/') {
- *commentEnd = start + 1;
- return true;
- }
- }
- // Block comment must close before end-of-input.
- return false;
- }
-
- return false;
-}
-
-template<typename Char>
-void skipWhitespaceAndComments(const Char* start, const Char* end, const Char** whitespaceEnd)
-{
- while (start < end) {
- if (isSpaceOrNewLine(*start)) {
- ++start;
- } else if (*start == '/') {
- const Char* commentEnd;
- if (!skipComment(start, end, &commentEnd))
- break;
- start = commentEnd;
- } else {
- break;
- }
- }
- *whitespaceEnd = start;
-}
-
-template<typename Char>
-Token parseToken(const Char* start, const Char* end, const Char** tokenStart, const Char** tokenEnd)
-{
- skipWhitespaceAndComments(start, end, tokenStart);
- start = *tokenStart;
-
- if (start == end)
- return InvalidToken;
-
- switch (*start) {
- case 'n':
- if (parseConstToken(start, end, tokenEnd, nullString))
- return NullToken;
- break;
- case 't':
- if (parseConstToken(start, end, tokenEnd, trueString))
- return BoolTrue;
- break;
- case 'f':
- if (parseConstToken(start, end, tokenEnd, falseString))
- return BoolFalse;
- break;
- case '[':
- *tokenEnd = start + 1;
- return ArrayBegin;
- case ']':
- *tokenEnd = start + 1;
- return ArrayEnd;
- case ',':
- *tokenEnd = start + 1;
- return ListSeparator;
- case '{':
- *tokenEnd = start + 1;
- return ObjectBegin;
- case '}':
- *tokenEnd = start + 1;
- return ObjectEnd;
- case ':':
- *tokenEnd = start + 1;
- return ObjectPairSeparator;
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- case '-':
- if (parseNumberToken(start, end, tokenEnd))
- return Number;
- break;
- case '"':
- if (parseStringToken(start + 1, end, tokenEnd))
- return StringLiteral;
- break;
- }
- return InvalidToken;
-}
-
-template<typename Char>
-int hexToInt(Char c)
-{
- if ('0' <= c && c <= '9')
- return c - '0';
- if ('A' <= c && c <= 'F')
- return c - 'A' + 10;
- if ('a' <= c && c <= 'f')
- return c - 'a' + 10;
- DCHECK(false);
- return 0;
-}
-
-template<typename Char>
-bool decodeString(const Char* start, const Char* end, StringBuilder* output)
-{
- while (start < end) {
- uint16_t c = *start++;
- if ('\\' != c) {
- output->append(c);
- continue;
- }
- if (start == end)
- return false;
- c = *start++;
-
- if (c == 'x') {
- // \x is not supported.
- return false;
- }
-
- switch (c) {
- case '"':
- case '/':
- case '\\':
- break;
- case 'b':
- c = '\b';
- break;
- case 'f':
- c = '\f';
- break;
- case 'n':
- c = '\n';
- break;
- case 'r':
- c = '\r';
- break;
- case 't':
- c = '\t';
- break;
- case 'v':
- c = '\v';
- break;
- case 'u':
- c = (hexToInt(*start) << 12) +
- (hexToInt(*(start + 1)) << 8) +
- (hexToInt(*(start + 2)) << 4) +
- hexToInt(*(start + 3));
- start += 4;
- break;
- default:
- return false;
- }
- output->append(c);
- }
- return true;
-}
-
-template<typename Char>
-bool decodeString(const Char* start, const Char* end, String* output)
-{
- if (start == end) {
- *output = "";
- return true;
- }
- if (start > end)
- return false;
- StringBuilder buffer;
- StringUtil::builderReserve(buffer, end - start);
- if (!decodeString(start, end, &buffer))
- return false;
- *output = buffer.toString();
- return true;
-}
-
-template<typename Char>
-std::unique_ptr<Value> buildValue(const Char* start, const Char* end, const Char** valueTokenEnd, int depth)
-{
- if (depth > stackLimit)
- return nullptr;
-
- std::unique_ptr<Value> result;
- const Char* tokenStart;
- const Char* tokenEnd;
- Token token = parseToken(start, end, &tokenStart, &tokenEnd);
- switch (token) {
- case InvalidToken:
- return nullptr;
- case NullToken:
- result = Value::null();
- break;
- case BoolTrue:
- result = FundamentalValue::create(true);
- break;
- case BoolFalse:
- result = FundamentalValue::create(false);
- break;
- case Number: {
- bool ok;
- double value = charactersToDouble(tokenStart, tokenEnd - tokenStart, &ok);
- if (!ok)
- return nullptr;
- int number = static_cast<int>(value);
- if (number == value)
- result = FundamentalValue::create(number);
- else
- result = FundamentalValue::create(value);
- break;
- }
- case StringLiteral: {
- String value;
- bool ok = decodeString(tokenStart + 1, tokenEnd - 1, &value);
- if (!ok)
- return nullptr;
- result = StringValue::create(value);
- break;
- }
- case ArrayBegin: {
- std::unique_ptr<ListValue> array = ListValue::create();
- start = tokenEnd;
- token = parseToken(start, end, &tokenStart, &tokenEnd);
- while (token != ArrayEnd) {
- std::unique_ptr<Value> arrayNode = buildValue(start, end, &tokenEnd, depth + 1);
- if (!arrayNode)
- return nullptr;
- array->pushValue(std::move(arrayNode));
-
- // After a list value, we expect a comma or the end of the list.
- start = tokenEnd;
- token = parseToken(start, end, &tokenStart, &tokenEnd);
- if (token == ListSeparator) {
- start = tokenEnd;
- token = parseToken(start, end, &tokenStart, &tokenEnd);
- if (token == ArrayEnd)
- return nullptr;
- } else if (token != ArrayEnd) {
- // Unexpected value after list value. Bail out.
- return nullptr;
- }
- }
- if (token != ArrayEnd)
- return nullptr;
- result = std::move(array);
- break;
- }
- case ObjectBegin: {
- std::unique_ptr<DictionaryValue> object = DictionaryValue::create();
- start = tokenEnd;
- token = parseToken(start, end, &tokenStart, &tokenEnd);
- while (token != ObjectEnd) {
- if (token != StringLiteral)
- return nullptr;
- String key;
- if (!decodeString(tokenStart + 1, tokenEnd - 1, &key))
- return nullptr;
- start = tokenEnd;
-
- token = parseToken(start, end, &tokenStart, &tokenEnd);
- if (token != ObjectPairSeparator)
- return nullptr;
- start = tokenEnd;
-
- std::unique_ptr<Value> value = buildValue(start, end, &tokenEnd, depth + 1);
- if (!value)
- return nullptr;
- object->setValue(key, std::move(value));
- start = tokenEnd;
-
- // After a key/value pair, we expect a comma or the end of the
- // object.
- token = parseToken(start, end, &tokenStart, &tokenEnd);
- if (token == ListSeparator) {
- start = tokenEnd;
- token = parseToken(start, end, &tokenStart, &tokenEnd);
- if (token == ObjectEnd)
- return nullptr;
- } else if (token != ObjectEnd) {
- // Unexpected value after last object value. Bail out.
- return nullptr;
- }
- }
- if (token != ObjectEnd)
- return nullptr;
- result = std::move(object);
- break;
- }
-
- default:
- // We got a token that's not a value.
- return nullptr;
- }
-
- skipWhitespaceAndComments(tokenEnd, end, valueTokenEnd);
- return result;
-}
-
-template<typename Char>
-std::unique_ptr<Value> parseJSONInternal(const Char* start, unsigned length)
-{
- const Char* end = start + length;
- const Char *tokenEnd;
- std::unique_ptr<Value> value = buildValue(start, end, &tokenEnd, 0);
- if (!value || tokenEnd != end)
- return nullptr;
- return value;
-}
-
-} // anonymous namespace
-
-std::unique_ptr<Value> parseJSON(const uint16_t* characters, unsigned length)
-{
- return parseJSONInternal<uint16_t>(characters, length);
-}
-
-std::unique_ptr<Value> parseJSON(const uint8_t* characters, unsigned length)
-{
- return parseJSONInternal<uint8_t>(characters, length);
-}
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/lib/Parser_h.template b/lib/Parser_h.template
deleted file mode 100644
index 7b2a29b..0000000
--- a/lib/Parser_h.template
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Parser_h
-#define {{"_".join(config.protocol.namespace)}}_Parser_h
-
-//#include "Forward.h"
-//#include "Values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-{{config.lib.export_macro}} std::unique_ptr<Value> parseJSON(const uint8_t*, unsigned);
-{{config.lib.export_macro}} std::unique_ptr<Value> parseJSON(const uint16_t*, unsigned);
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Parser_h)
diff --git a/lib/Protocol_cpp.template b/lib/Protocol_cpp.template
deleted file mode 100644
index 8e35fa7..0000000
--- a/lib/Protocol_cpp.template
+++ /dev/null
@@ -1,12 +0,0 @@
-// This file is generated.
-
-// 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.
-
-#include "{{config.protocol.package}}/Protocol.h"
-
-#include <algorithm>
-#include <cmath>
-
-#include <cstring>
diff --git a/lib/ValueConversions_h.template b/lib/ValueConversions_h.template
deleted file mode 100644
index 5384c7b..0000000
--- a/lib/ValueConversions_h.template
+++ /dev/null
@@ -1,171 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_ValueConversions_h
-#define {{"_".join(config.protocol.namespace)}}_ValueConversions_h
-
-//#include "ErrorSupport.h"
-//#include "Forward.h"
-//#include "Values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-template<typename T>
-struct ValueConversions {
- static std::unique_ptr<T> parse(protocol::Value* value, ErrorSupport* errors)
- {
- return T::parse(value, errors);
- }
-
- static std::unique_ptr<protocol::Value> serialize(T* value)
- {
- return value->serialize();
- }
-
- static std::unique_ptr<protocol::Value> serialize(const std::unique_ptr<T>& value)
- {
- return value->serialize();
- }
-};
-
-template<>
-struct ValueConversions<bool> {
- static bool parse(protocol::Value* value, ErrorSupport* errors)
- {
- bool result = false;
- bool success = value ? value->asBoolean(&result) : false;
- if (!success)
- errors->addError("boolean value expected");
- return result;
- }
-
- static std::unique_ptr<protocol::Value> serialize(bool value)
- {
- return FundamentalValue::create(value);
- }
-};
-
-template<>
-struct ValueConversions<int> {
- static int parse(protocol::Value* value, ErrorSupport* errors)
- {
- int result = 0;
- bool success = value ? value->asInteger(&result) : false;
- if (!success)
- errors->addError("integer value expected");
- return result;
- }
-
- static std::unique_ptr<protocol::Value> serialize(int value)
- {
- return FundamentalValue::create(value);
- }
-};
-
-template<>
-struct ValueConversions<double> {
- static double parse(protocol::Value* value, ErrorSupport* errors)
- {
- double result = 0;
- bool success = value ? value->asDouble(&result) : false;
- if (!success)
- errors->addError("double value expected");
- return result;
- }
-
- static std::unique_ptr<protocol::Value> serialize(double value)
- {
- return FundamentalValue::create(value);
- }
-};
-
-template<>
-struct ValueConversions<String> {
- static String parse(protocol::Value* value, ErrorSupport* errors)
- {
- String result;
- bool success = value ? value->asString(&result) : false;
- if (!success)
- errors->addError("string value expected");
- return result;
- }
-
- static std::unique_ptr<protocol::Value> serialize(const String& value)
- {
- return StringValue::create(value);
- }
-};
-
-template<>
-struct ValueConversions<Value> {
- static std::unique_ptr<Value> parse(protocol::Value* value, ErrorSupport* errors)
- {
- bool success = !!value;
- if (!success) {
- errors->addError("value expected");
- return nullptr;
- }
- return value->clone();
- }
-
- static std::unique_ptr<protocol::Value> serialize(Value* value)
- {
- return value->clone();
- }
-
- static std::unique_ptr<protocol::Value> serialize(const std::unique_ptr<Value>& value)
- {
- return value->clone();
- }
-};
-
-template<>
-struct ValueConversions<DictionaryValue> {
- static std::unique_ptr<DictionaryValue> parse(protocol::Value* value, ErrorSupport* errors)
- {
- bool success = value && value->type() == protocol::Value::TypeObject;
- if (!success)
- errors->addError("object expected");
- return DictionaryValue::cast(value->clone());
- }
-
- static std::unique_ptr<protocol::Value> serialize(DictionaryValue* value)
- {
- return value->clone();
- }
-
- static std::unique_ptr<protocol::Value> serialize(const std::unique_ptr<DictionaryValue>& value)
- {
- return value->clone();
- }
-};
-
-template<>
-struct ValueConversions<ListValue> {
- static std::unique_ptr<ListValue> parse(protocol::Value* value, ErrorSupport* errors)
- {
- bool success = value && value->type() == protocol::Value::TypeArray;
- if (!success)
- errors->addError("list expected");
- return ListValue::cast(value->clone());
- }
-
- static std::unique_ptr<protocol::Value> serialize(ListValue* value)
- {
- return value->clone();
- }
-
- static std::unique_ptr<protocol::Value> serialize(const std::unique_ptr<ListValue>& value)
- {
- return value->clone();
- }
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_ValueConversions_h)
diff --git a/lib/Values_cpp.template b/lib/Values_cpp.template
deleted file mode 100644
index 1b5cdfe..0000000
--- a/lib/Values_cpp.template
+++ /dev/null
@@ -1,407 +0,0 @@
-// 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.
-
-//#include "Values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-namespace {
-
-const char* const nullValueString = "null";
-const char* const trueValueString = "true";
-const char* const falseValueString = "false";
-
-inline bool escapeChar(uint16_t c, StringBuilder* dst)
-{
- switch (c) {
- case '\b': dst->append("\\b"); break;
- case '\f': dst->append("\\f"); break;
- case '\n': dst->append("\\n"); break;
- case '\r': dst->append("\\r"); break;
- case '\t': dst->append("\\t"); break;
- case '\\': dst->append("\\\\"); break;
- case '"': dst->append("\\\""); break;
- default:
- return false;
- }
- return true;
-}
-
-const char hexDigits[17] = "0123456789ABCDEF";
-
-void appendUnsignedAsHex(uint16_t number, StringBuilder* dst)
-{
- dst->append("\\u");
- for (size_t i = 0; i < 4; ++i) {
- uint16_t c = hexDigits[(number & 0xF000) >> 12];
- dst->append(c);
- number <<= 4;
- }
-}
-
-void escapeStringForJSON(const String& str, StringBuilder* dst)
-{
- for (unsigned i = 0; i < str.length(); ++i) {
- uint16_t c = str[i];
- if (!escapeChar(c, dst)) {
- if (c < 32 || c > 126 || c == '<' || c == '>') {
- // 1. Escaping <, > to prevent script execution.
- // 2. Technically, we could also pass through c > 126 as UTF8, but this
- // is also optional. It would also be a pain to implement here.
- appendUnsignedAsHex(c, dst);
- } else {
- dst->append(c);
- }
- }
- }
-}
-
-void doubleQuoteStringForJSON(const String& str, StringBuilder* dst)
-{
- dst->append('"');
- escapeStringForJSON(str, dst);
- dst->append('"');
-}
-
-} // anonymous namespace
-
-bool Value::asBoolean(bool*) const
-{
- return false;
-}
-
-bool Value::asDouble(double*) const
-{
- return false;
-}
-
-bool Value::asInteger(int*) const
-{
- return false;
-}
-
-bool Value::asString(String*) const
-{
- return false;
-}
-
-bool Value::asSerialized(String*) const
-{
- return false;
-}
-
-String Value::toJSONString() const
-{
- StringBuilder result;
- StringUtil::builderReserve(result, 512);
- writeJSON(&result);
- return result.toString();
-}
-
-void Value::writeJSON(StringBuilder* output) const
-{
- DCHECK(m_type == TypeNull);
- output->append(nullValueString, 4);
-}
-
-std::unique_ptr<Value> Value::clone() const
-{
- return Value::null();
-}
-
-bool FundamentalValue::asBoolean(bool* output) const
-{
- if (type() != TypeBoolean)
- return false;
- *output = m_boolValue;
- return true;
-}
-
-bool FundamentalValue::asDouble(double* output) const
-{
- if (type() == TypeDouble) {
- *output = m_doubleValue;
- return true;
- }
- if (type() == TypeInteger) {
- *output = m_integerValue;
- return true;
- }
- return false;
-}
-
-bool FundamentalValue::asInteger(int* output) const
-{
- if (type() != TypeInteger)
- return false;
- *output = m_integerValue;
- return true;
-}
-
-void FundamentalValue::writeJSON(StringBuilder* output) const
-{
- DCHECK(type() == TypeBoolean || type() == TypeInteger || type() == TypeDouble);
- if (type() == TypeBoolean) {
- if (m_boolValue)
- output->append(trueValueString, 4);
- else
- output->append(falseValueString, 5);
- } else if (type() == TypeDouble) {
- if (!std::isfinite(m_doubleValue)) {
- output->append(nullValueString, 4);
- return;
- }
- output->append(StringUtil::fromDouble(m_doubleValue));
- } else if (type() == TypeInteger) {
- output->append(StringUtil::fromInteger(m_integerValue));
- }
-}
-
-std::unique_ptr<Value> FundamentalValue::clone() const
-{
- switch (type()) {
- case TypeDouble: return FundamentalValue::create(m_doubleValue);
- case TypeInteger: return FundamentalValue::create(m_integerValue);
- case TypeBoolean: return FundamentalValue::create(m_boolValue);
- default:
- DCHECK(false);
- }
- return nullptr;
-}
-
-bool StringValue::asString(String* output) const
-{
- *output = m_stringValue;
- return true;
-}
-
-void StringValue::writeJSON(StringBuilder* output) const
-{
- DCHECK(type() == TypeString);
- doubleQuoteStringForJSON(m_stringValue, output);
-}
-
-std::unique_ptr<Value> StringValue::clone() const
-{
- return StringValue::create(m_stringValue);
-}
-
-bool SerializedValue::asSerialized(String* output) const
-{
- *output = m_serializedValue;
- return true;
-}
-
-void SerializedValue::writeJSON(StringBuilder* output) const
-{
- DCHECK(type() == TypeSerialized);
- output->append(m_serializedValue);
-}
-
-std::unique_ptr<Value> SerializedValue::clone() const
-{
- return SerializedValue::create(m_serializedValue);
-}
-
-DictionaryValue::~DictionaryValue()
-{
-}
-
-void DictionaryValue::setBoolean(const String& name, bool value)
-{
- setValue(name, FundamentalValue::create(value));
-}
-
-void DictionaryValue::setInteger(const String& name, int value)
-{
- setValue(name, FundamentalValue::create(value));
-}
-
-void DictionaryValue::setDouble(const String& name, double value)
-{
- setValue(name, FundamentalValue::create(value));
-}
-
-void DictionaryValue::setString(const String& name, const String& value)
-{
- setValue(name, StringValue::create(value));
-}
-
-void DictionaryValue::setValue(const String& name, std::unique_ptr<Value> value)
-{
- set(name, value);
-}
-
-void DictionaryValue::setObject(const String& name, std::unique_ptr<DictionaryValue> value)
-{
- set(name, value);
-}
-
-void DictionaryValue::setArray(const String& name, std::unique_ptr<ListValue> value)
-{
- set(name, value);
-}
-
-bool DictionaryValue::getBoolean(const String& name, bool* output) const
-{
- protocol::Value* value = get(name);
- if (!value)
- return false;
- return value->asBoolean(output);
-}
-
-bool DictionaryValue::getInteger(const String& name, int* output) const
-{
- Value* value = get(name);
- if (!value)
- return false;
- return value->asInteger(output);
-}
-
-bool DictionaryValue::getDouble(const String& name, double* output) const
-{
- Value* value = get(name);
- if (!value)
- return false;
- return value->asDouble(output);
-}
-
-bool DictionaryValue::getString(const String& name, String* output) const
-{
- protocol::Value* value = get(name);
- if (!value)
- return false;
- return value->asString(output);
-}
-
-DictionaryValue* DictionaryValue::getObject(const String& name) const
-{
- return DictionaryValue::cast(get(name));
-}
-
-protocol::ListValue* DictionaryValue::getArray(const String& name) const
-{
- return ListValue::cast(get(name));
-}
-
-protocol::Value* DictionaryValue::get(const String& name) const
-{
- Dictionary::const_iterator it = m_data.find(name);
- if (it == m_data.end())
- return nullptr;
- return it->second.get();
-}
-
-DictionaryValue::Entry DictionaryValue::at(size_t index) const
-{
- const String key = m_order[index];
- return std::make_pair(key, m_data.find(key)->second.get());
-}
-
-bool DictionaryValue::booleanProperty(const String& name, bool defaultValue) const
-{
- bool result = defaultValue;
- getBoolean(name, &result);
- return result;
-}
-
-int DictionaryValue::integerProperty(const String& name, int defaultValue) const
-{
- int result = defaultValue;
- getInteger(name, &result);
- return result;
-}
-
-double DictionaryValue::doubleProperty(const String& name, double defaultValue) const
-{
- double result = defaultValue;
- getDouble(name, &result);
- return result;
-}
-
-void DictionaryValue::remove(const String& name)
-{
- m_data.erase(name);
- m_order.erase(std::remove(m_order.begin(), m_order.end(), name), m_order.end());
-}
-
-void DictionaryValue::writeJSON(StringBuilder* output) const
-{
- output->append('{');
- for (size_t i = 0; i < m_order.size(); ++i) {
- Dictionary::const_iterator it = m_data.find(m_order[i]);
- CHECK(it != m_data.end());
- if (i)
- output->append(',');
- doubleQuoteStringForJSON(it->first, output);
- output->append(':');
- it->second->writeJSON(output);
- }
- output->append('}');
-}
-
-std::unique_ptr<Value> DictionaryValue::clone() const
-{
- std::unique_ptr<DictionaryValue> result = DictionaryValue::create();
- for (size_t i = 0; i < m_order.size(); ++i) {
- String key = m_order[i];
- Dictionary::const_iterator value = m_data.find(key);
- DCHECK(value != m_data.cend() && value->second);
- result->setValue(key, value->second->clone());
- }
- return std::move(result);
-}
-
-DictionaryValue::DictionaryValue()
- : Value(TypeObject)
-{
-}
-
-ListValue::~ListValue()
-{
-}
-
-void ListValue::writeJSON(StringBuilder* output) const
-{
- output->append('[');
- bool first = true;
- for (const std::unique_ptr<protocol::Value>& value : m_data) {
- if (!first)
- output->append(',');
- value->writeJSON(output);
- first = false;
- }
- output->append(']');
-}
-
-std::unique_ptr<Value> ListValue::clone() const
-{
- std::unique_ptr<ListValue> result = ListValue::create();
- for (const std::unique_ptr<protocol::Value>& value : m_data)
- result->pushValue(value->clone());
- return std::move(result);
-}
-
-ListValue::ListValue()
- : Value(TypeArray)
-{
-}
-
-void ListValue::pushValue(std::unique_ptr<protocol::Value> value)
-{
- DCHECK(value);
- m_data.push_back(std::move(value));
-}
-
-protocol::Value* ListValue::at(size_t index)
-{
- DCHECK_LT(index, m_data.size());
- return m_data[index].get();
-}
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/lib/Values_h.template b/lib/Values_h.template
deleted file mode 100644
index 8f75ef2..0000000
--- a/lib/Values_h.template
+++ /dev/null
@@ -1,246 +0,0 @@
-// 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Values_h
-#define {{"_".join(config.protocol.namespace)}}_Values_h
-
-//#include "Allocator.h"
-//#include "Collections.h"
-//#include "Forward.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class ListValue;
-class DictionaryValue;
-class Value;
-
-class {{config.lib.export_macro}} Value {
- PROTOCOL_DISALLOW_COPY(Value);
-public:
- virtual ~Value() { }
-
- static std::unique_ptr<Value> null()
- {
- return wrapUnique(new Value());
- }
-
- enum ValueType {
- TypeNull = 0,
- TypeBoolean,
- TypeInteger,
- TypeDouble,
- TypeString,
- TypeObject,
- TypeArray,
- TypeSerialized
- };
-
- ValueType type() const { return m_type; }
-
- bool isNull() const { return m_type == TypeNull; }
-
- virtual bool asBoolean(bool* output) const;
- virtual bool asDouble(double* output) const;
- virtual bool asInteger(int* output) const;
- virtual bool asString(String* output) const;
- virtual bool asSerialized(String* output) const;
-
- String toJSONString() const;
- virtual void writeJSON(StringBuilder* output) const;
- virtual std::unique_ptr<Value> clone() const;
-
-protected:
- Value() : m_type(TypeNull) { }
- explicit Value(ValueType type) : m_type(type) { }
-
-private:
- friend class DictionaryValue;
- friend class ListValue;
-
- ValueType m_type;
-};
-
-class {{config.lib.export_macro}} FundamentalValue : public Value {
-public:
- static std::unique_ptr<FundamentalValue> create(bool value)
- {
- return wrapUnique(new FundamentalValue(value));
- }
-
- static std::unique_ptr<FundamentalValue> create(int value)
- {
- return wrapUnique(new FundamentalValue(value));
- }
-
- static std::unique_ptr<FundamentalValue> create(double value)
- {
- return wrapUnique(new FundamentalValue(value));
- }
-
- bool asBoolean(bool* output) const override;
- bool asDouble(double* output) const override;
- bool asInteger(int* output) const override;
- void writeJSON(StringBuilder* output) const override;
- std::unique_ptr<Value> clone() const override;
-
-private:
- explicit FundamentalValue(bool value) : Value(TypeBoolean), m_boolValue(value) { }
- explicit FundamentalValue(int value) : Value(TypeInteger), m_integerValue(value) { }
- explicit FundamentalValue(double value) : Value(TypeDouble), m_doubleValue(value) { }
-
- union {
- bool m_boolValue;
- double m_doubleValue;
- int m_integerValue;
- };
-};
-
-class {{config.lib.export_macro}} StringValue : public Value {
-public:
- static std::unique_ptr<StringValue> create(const String& value)
- {
- return wrapUnique(new StringValue(value));
- }
-
- static std::unique_ptr<StringValue> create(const char* value)
- {
- return wrapUnique(new StringValue(value));
- }
-
- bool asString(String* output) const override;
- void writeJSON(StringBuilder* output) const override;
- std::unique_ptr<Value> clone() const override;
-
-private:
- explicit StringValue(const String& value) : Value(TypeString), m_stringValue(value) { }
- explicit StringValue(const char* value) : Value(TypeString), m_stringValue(value) { }
-
- String m_stringValue;
-};
-
-class {{config.lib.export_macro}} SerializedValue : public Value {
-public:
- static std::unique_ptr<SerializedValue> create(const String& value)
- {
- return wrapUnique(new SerializedValue(value));
- }
-
- bool asSerialized(String* output) const override;
- void writeJSON(StringBuilder* output) const override;
- std::unique_ptr<Value> clone() const override;
-
-private:
- explicit SerializedValue(const String& value) : Value(TypeSerialized), m_serializedValue(value) { }
-
- String m_serializedValue;
-};
-
-class {{config.lib.export_macro}} DictionaryValue : public Value {
-public:
- using Entry = std::pair<String, Value*>;
- static std::unique_ptr<DictionaryValue> create()
- {
- return wrapUnique(new DictionaryValue());
- }
-
- static DictionaryValue* cast(Value* value)
- {
- if (!value || value->type() != TypeObject)
- return nullptr;
- return static_cast<DictionaryValue*>(value);
- }
-
- static std::unique_ptr<DictionaryValue> cast(std::unique_ptr<Value> value)
- {
- return wrapUnique(DictionaryValue::cast(value.release()));
- }
-
- void writeJSON(StringBuilder* output) const override;
- std::unique_ptr<Value> clone() const override;
-
- size_t size() const { return m_data.size(); }
-
- void setBoolean(const String& name, bool);
- void setInteger(const String& name, int);
- void setDouble(const String& name, double);
- void setString(const String& name, const String&);
- void setValue(const String& name, std::unique_ptr<Value>);
- void setObject(const String& name, std::unique_ptr<DictionaryValue>);
- void setArray(const String& name, std::unique_ptr<ListValue>);
-
- bool getBoolean(const String& name, bool* output) const;
- bool getInteger(const String& name, int* output) const;
- bool getDouble(const String& name, double* output) const;
- bool getString(const String& name, String* output) const;
-
- DictionaryValue* getObject(const String& name) const;
- ListValue* getArray(const String& name) const;
- Value* get(const String& name) const;
- Entry at(size_t index) const;
-
- bool booleanProperty(const String& name, bool defaultValue) const;
- int integerProperty(const String& name, int defaultValue) const;
- double doubleProperty(const String& name, double defaultValue) const;
- void remove(const String& name);
-
- ~DictionaryValue() override;
-
-private:
- DictionaryValue();
- template<typename T>
- void set(const String& key, std::unique_ptr<T>& value)
- {
- DCHECK(value);
- bool isNew = m_data.find(key) == m_data.end();
- m_data[key] = std::move(value);
- if (isNew)
- m_order.push_back(key);
- }
-
- using Dictionary = protocol::HashMap<String, std::unique_ptr<Value>>;
- Dictionary m_data;
- std::vector<String> m_order;
-};
-
-class {{config.lib.export_macro}} ListValue : public Value {
-public:
- static std::unique_ptr<ListValue> create()
- {
- return wrapUnique(new ListValue());
- }
-
- static ListValue* cast(Value* value)
- {
- if (!value || value->type() != TypeArray)
- return nullptr;
- return static_cast<ListValue*>(value);
- }
-
- static std::unique_ptr<ListValue> cast(std::unique_ptr<Value> value)
- {
- return wrapUnique(ListValue::cast(value.release()));
- }
-
- ~ListValue() override;
-
- void writeJSON(StringBuilder* output) const override;
- std::unique_ptr<Value> clone() const override;
-
- void pushValue(std::unique_ptr<Value>);
-
- Value* at(size_t index);
- size_t size() const { return m_data.size(); }
-
-private:
- ListValue();
- std::vector<std::unique_ptr<Value>> m_data;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // {{"_".join(config.protocol.namespace)}}_Values_h
diff --git a/sample_config.json b/sample_config.json
deleted file mode 100644
index 82d7845..0000000
--- a/sample_config.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "protocol": {
- "path": "./relative/path/protocol/sample_protocol.json",
- "package": "include/generated/files/like/this",
- "output": "place/generated/files/here",
- "namespace": ["sample_project", "protocol"],
- "export_macro": "LIB_EXPORT",
- "export_header": "lib/lib_export.h"
- },
-
- "exported": {
- "package": "include/exported/files/like/this",
- "output": "place/exported/files/here",
- "string_header": "include/exported/string.h",
- "string_in": "String",
- "string_out": "String",
- "to_string_out": "toString(%s)",
- "export_macro": "LIB_EXPORT",
- "export_header": "lib/lib_export.h"
- },
-
- "imported": {
- "path": "../relative/path/imported_protocol.json",
- "package": "either/include/imported/files/from/here",
- "header": "or/include/them/all/together/like/this/imported_protocol.h",
- "to_imported_string": "toImportedString(%s)",
- "from_imported_string": "fromImportedString(%s)",
- "namespace": ["imported_project", "protocol"]
- },
-
- "lib": {
- "package": "include/lib/files/like/this",
- "output": "place/generated/lib/files/here",
- "string_header": "string/implementation.h",
- "platform_header": "platform/implementation.h",
- "export_macro": "LIB_EXPORT",
- "export_header": "lib/lib_export.h"
- }
-}
diff --git a/sample_expected_errors.json b/sample_expected_errors.json
deleted file mode 100644
index 85fa264..0000000
--- a/sample_expected_errors.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
- "errors": [
- "Domain.event: event has been removed",
- "Domain.command: command has been removed",
- "Domain.command.param parameter->Domain.TypeName.property: required property has been removed"
- ]
-}
\ No newline at end of file
diff --git a/templates/Exported_h.template b/templates/Exported_h.template
deleted file mode 100644
index 3357f95..0000000
--- a/templates/Exported_h.template
+++ /dev/null
@@ -1,65 +0,0 @@
-// This file is generated
-
-// Copyright (c) 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_{{domain.domain}}_api_h
-#define {{"_".join(config.protocol.namespace)}}_{{domain.domain}}_api_h
-
-{% if config.exported.export_header %}
-#include {{format_include(config.exported.export_header)}}
-{% endif %}
-#include {{format_include(config.exported.string_header)}}
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-namespace {{domain.domain}} {
-namespace API {
-
-// ------------- Enums.
- {% for type in domain.types %}
- {% if ("enum" in type) and type.exported %}
-
-namespace {{type.id}}Enum {
- {% for literal in type.enum %}
-{{config.exported.export_macro}} extern const char* {{ literal | dash_to_camelcase}};
- {% endfor %}
-} // {{type.id}}Enum
- {% endif %}
- {% endfor %}
- {% for command in join_arrays(domain, ["commands", "events"]) %}
- {% for param in join_arrays(command, ["parameters", "returns"]) %}
- {% if ("enum" in param) and (param.exported) %}
-
-namespace {{command.name | to_title_case}} {
-namespace {{param.name | to_title_case}}Enum {
- {% for literal in param.enum %}
-{{config.exported.export_macro}} extern const char* {{ literal | dash_to_camelcase}};
- {% endfor %}
-} // {{param.name | to_title_case}}Enum
-} // {{command.name | to_title_case }}
- {% endif %}
- {% endfor %}
- {% endfor %}
-
-// ------------- Types.
- {% for type in domain.types %}
- {% if not (type.type == "object") or not ("properties" in type) or not (type.exported) %}{% continue %}{% endif %}
-
-class {{config.exported.export_macro}} {{type.id}} {
-public:
- virtual {{config.exported.string_out}} toJSONString() const = 0;
- virtual ~{{type.id}}() { }
- static std::unique_ptr<protocol::{{domain.domain}}::API::{{type.id}}> fromJSONString(const {{config.exported.string_in}}& json);
-};
- {% endfor %}
-
-} // namespace API
-} // namespace {{domain.domain}}
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_{{domain.domain}}_api_h)
diff --git a/templates/Imported_h.template b/templates/Imported_h.template
deleted file mode 100644
index c23b8fe..0000000
--- a/templates/Imported_h.template
+++ /dev/null
@@ -1,51 +0,0 @@
-// This file is generated
-
-// Copyright (c) 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_{{domain.domain}}_imported_h
-#define {{"_".join(config.protocol.namespace)}}_{{domain.domain}}_imported_h
-
-#include "{{config.protocol.package}}/Protocol.h"
-#include {{format_include(config.imported.header if config.imported.header else "\"%s/%s.h\"" % (config.imported.package, domain.domain))}}
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
- {% for type in domain.types %}
- {% if not (type.type == "object") or not ("properties" in type) or not (type.exported) %}{% continue %}{% endif %}
-
-template<>
-struct ValueConversions<{{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}> {
- static std::unique_ptr<{{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}> parse(protocol::Value* value, ErrorSupport* errors)
- {
- if (!value) {
- errors->addError("value expected");
- return nullptr;
- }
- String json = value->toJSONString();
- auto result = {{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}::fromJSONString({{config.imported.to_imported_string % "json"}});
- if (!result)
- errors->addError("cannot parse");
- return result;
- }
-
- static std::unique_ptr<protocol::Value> serialize(const {{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}* value)
- {
- auto json = value->toJSONString();
- return SerializedValue::create({{config.imported.from_imported_string % "std::move(json)"}});
- }
-
- static std::unique_ptr<protocol::Value> serialize(const std::unique_ptr<{{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}>& value)
- {
- return serialize(value.get());
- }
-};
- {% endfor %}
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_{{domain.domain}}_imported_h)
diff --git a/templates/TypeBuilder_cpp.template b/templates/TypeBuilder_cpp.template
deleted file mode 100644
index 0ea21e9..0000000
--- a/templates/TypeBuilder_cpp.template
+++ /dev/null
@@ -1,359 +0,0 @@
-// This file is generated
-
-// Copyright (c) 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.
-
-#include "{{config.protocol.package}}/{{domain.domain}}.h"
-
-#include "{{config.protocol.package}}/Protocol.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-namespace {{domain.domain}} {
-
-// ------------- Enum values from types.
-
-const char Metainfo::domainName[] = "{{domain.domain}}";
-const char Metainfo::commandPrefix[] = "{{domain.domain}}.";
-const char Metainfo::version[] = "{{domain.version}}";
- {% for type in domain.types %}
- {% if "enum" in type %}
-
-namespace {{type.id}}Enum {
- {% for literal in type.enum %}
-const char* {{ literal | dash_to_camelcase}} = "{{literal}}";
- {% endfor %}
-} // namespace {{type.id}}Enum
- {% if type.exported %}
-
-namespace API {
-namespace {{type.id}}Enum {
- {% for literal in type.enum %}
-const char* {{ literal | dash_to_camelcase}} = "{{literal}}";
- {% endfor %}
-} // namespace {{type.id}}Enum
-} // namespace API
- {% endif %}
- {% endif %}
- {% for property in type.properties %}
- {% if "enum" in property %}
-
- {% for literal in property.enum %}
-const char* {{type.id}}::{{property.name | to_title_case}}Enum::{{literal | dash_to_camelcase}} = "{{literal}}";
- {% endfor %}
- {% endif %}
- {% endfor %}
- {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
-
-std::unique_ptr<{{type.id}}> {{type.id}}::parse(protocol::Value* value, ErrorSupport* errors)
-{
- if (!value || value->type() != protocol::Value::TypeObject) {
- errors->addError("object expected");
- return nullptr;
- }
-
- std::unique_ptr<{{type.id}}> result(new {{type.id}}());
- protocol::DictionaryValue* object = DictionaryValue::cast(value);
- errors->push();
- {% for property in type.properties %}
- protocol::Value* {{property.name}}Value = object->get("{{property.name}}");
- {% if property.optional %}
- if ({{property.name}}Value) {
- errors->setName("{{property.name}}");
- result->m_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
- }
- {% else %}
- errors->setName("{{property.name}}");
- result->m_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
- {% endif %}
- {% endfor %}
- errors->pop();
- if (errors->hasErrors())
- return nullptr;
- return result;
-}
-
-std::unique_ptr<protocol::DictionaryValue> {{type.id}}::serialize() const
-{
- std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
- {% for property in type.properties %}
- {% if property.optional %}
- if (m_{{property.name}}.isJust())
- result->setValue("{{property.name}}", ValueConversions<{{resolve_type(property).raw_type}}>::serialize(m_{{property.name}}.fromJust()));
- {% else %}
- result->setValue("{{property.name}}", ValueConversions<{{resolve_type(property).raw_type}}>::serialize({{resolve_type(property).to_raw_type % ("m_" + property.name)}}));
- {% endif %}
- {% endfor %}
- return result;
-}
-
-std::unique_ptr<{{type.id}}> {{type.id}}::clone() const
-{
- ErrorSupport errors;
- return parse(serialize().get(), &errors);
-}
- {% if type.exported %}
-
-{{config.exported.string_out}} {{type.id}}::toJSONString() const
-{
- String json = serialize()->toJSONString();
- return {{config.exported.to_string_out % "json"}};
-}
-
-// static
-std::unique_ptr<API::{{type.id}}> API::{{type.id}}::fromJSONString(const {{config.exported.string_in}}& json)
-{
- ErrorSupport errors;
- std::unique_ptr<Value> value = parseJSON(json);
- if (!value)
- return nullptr;
- return protocol::{{domain.domain}}::{{type.id}}::parse(value.get(), &errors);
-}
- {% endif %}
- {% endfor %}
-
-// ------------- Enum values from params.
-
- {% for command in join_arrays(domain, ["commands", "events"]) %}
- {% for param in join_arrays(command, ["parameters", "returns"]) %}
- {% if "enum" in param %}
-
-namespace {{command.name | to_title_case}} {
-namespace {{param.name | to_title_case}}Enum {
- {% for literal in param.enum %}
-const char* {{ literal | to_title_case}} = "{{literal}}";
- {% endfor %}
-} // namespace {{param.name | to_title_case}}Enum
-} // namespace {{command.name | to_title_case }}
- {% if param.exported %}
-
-namespace API {
-namespace {{command.name | to_title_case}} {
-namespace {{param.name | to_title_case}}Enum {
- {% for literal in param.enum %}
-const char* {{ literal | to_title_case}} = "{{literal}}";
- {% endfor %}
-} // namespace {{param.name | to_title_case}}Enum
-} // namespace {{command.name | to_title_case }}
-} // namespace API
- {% endif %}
- {% endif %}
- {% endfor %}
- {% endfor %}
-
-// ------------- Frontend notifications.
- {% for event in domain.events %}
- {% if "handlers" in event and not ("renderer" in event["handlers"]) %}{% continue %}{% endif %}
-
-void Frontend::{{event.name}}(
- {%- for parameter in event.parameters %}
- {% if "optional" in parameter -%}
- const Maybe<{{resolve_type(parameter).raw_type}}>&
- {%- else -%}
- {{resolve_type(parameter).pass_type}}
- {%- endif %} {{parameter.name}}{%- if not loop.last -%}, {% endif -%}
- {% endfor -%})
-{
- std::unique_ptr<protocol::DictionaryValue> jsonMessage = DictionaryValue::create();
- jsonMessage->setString("method", "{{domain.domain}}.{{event.name}}");
- std::unique_ptr<protocol::DictionaryValue> paramsObject = DictionaryValue::create();
- {% for parameter in event.parameters %}
- {% if "optional" in parameter %}
- if ({{parameter.name}}.isJust())
- paramsObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{parameter.name}}.fromJust()));
- {% else %}
- paramsObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % parameter.name}}));
- {% endif %}
- {% endfor %}
- jsonMessage->setObject("params", std::move(paramsObject));
- if (m_frontendChannel)
- m_frontendChannel->sendProtocolNotification(jsonMessage->toJSONString());
-}
- {% endfor %}
-
-void Frontend::flush()
-{
- m_frontendChannel->flushProtocolNotifications();
-}
-
-// --------------------- Dispatcher.
-
-class DispatcherImpl : public protocol::DispatcherBase {
-public:
- DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
- : DispatcherBase(frontendChannel)
- , m_backend(backend) {
- {% for command in domain.commands %}
- {% if "redirect" in command %}{% continue %}{% endif %}
- {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
- m_dispatchMap["{{domain.domain}}.{{command.name}}"] = &DispatcherImpl::{{command.name}};
- {% endfor %}
- }
- ~DispatcherImpl() override { }
- void dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
-
-protected:
- using CallHandler = void (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
- using DispatchMap = protocol::HashMap<String, CallHandler>;
- DispatchMap m_dispatchMap;
-
- {% for command in domain.commands %}
- {% if "redirect" in command %}{% continue %}{% endif %}
- {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
- void {{command.name}}(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
- {% endfor %}
-
- Backend* m_backend;
-};
-
-void DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject)
-{
- protocol::HashMap<String, CallHandler>::iterator it = m_dispatchMap.find(method);
- if (it == m_dispatchMap.end()) {
- reportProtocolError(callId, MethodNotFound, "'" + method + "' wasn't found", nullptr);
- return;
- }
-
- protocol::ErrorSupport errors;
- (this->*(it->second))(callId, std::move(messageObject), &errors);
-}
-
- {% for command in domain.commands %}
- {% if "redirect" in command %}{% continue %}{% endif %}
- {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
- {% if "async" in command %}
-
-class {{command.name | to_title_case}}CallbackImpl : public Backend::{{command.name | to_title_case}}Callback, public DispatcherBase::Callback {
-public:
- {{command.name | to_title_case}}CallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId)
- : DispatcherBase::Callback(std::move(backendImpl), callId) { }
-
- void sendSuccess(
- {%- for parameter in command.returns -%}
- {%- if "optional" in parameter -%}
- const Maybe<{{resolve_type(parameter).raw_type}}>& {{parameter.name}}
- {%- else -%}
- {{resolve_type(parameter).pass_type}} {{parameter.name}}
- {%- endif -%}
- {%- if not loop.last -%}, {% endif -%}
- {%- endfor -%}) override
- {
- std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
- {% for parameter in command.returns %}
- {% if "optional" in parameter %}
- if ({{parameter.name}}.isJust())
- resultObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{parameter.name}}.fromJust()));
- {% else %}
- resultObject->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % parameter.name}}));
- {% endif %}
- {% endfor %}
- sendIfActive(std::move(resultObject), ErrorString());
- }
-
- void sendFailure(const ErrorString& error) override
- {
- DCHECK(error.length());
- sendIfActive(nullptr, error);
- }
-
-};
- {% endif %}
-
-void DispatcherImpl::{{command.name}}(int callId, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
-{
- {% if "parameters" in command %}
- // Prepare input parameters.
- protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
- errors->push();
- {% for property in command.parameters %}
- protocol::Value* {{property.name}}Value = object ? object->get("{{property.name}}") : nullptr;
- {% if property.optional %}
- Maybe<{{resolve_type(property).raw_type}}> in_{{property.name}};
- if ({{property.name}}Value) {
- errors->setName("{{property.name}}");
- in_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
- }
- {% else %}
- errors->setName("{{property.name}}");
- {{resolve_type(property).type}} in_{{property.name}} = ValueConversions<{{resolve_type(property).raw_type}}>::parse({{property.name}}Value, errors);
- {% endif %}
- {% endfor %}
- errors->pop();
- if (errors->hasErrors()) {
- reportProtocolError(callId, InvalidParams, kInvalidRequest, errors);
- return;
- }
- {% endif %}
- {% if "async" in command %}
- std::unique_ptr<{{command.name | to_title_case}}CallbackImpl> callback(new {{command.name | to_title_case}}CallbackImpl(weakPtr(), callId));
- {% elif "returns" in command %}
- // Declare output parameters.
- std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
- {% for property in command.returns %}
- {% if "optional" in property %}
- Maybe<{{resolve_type(property).raw_type}}> out_{{property.name}};
- {% else %}
- {{resolve_type(property).type}} out_{{property.name}};
- {% endif %}
- {% endfor %}
- {% endif %}
-
- std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
- {% if not("async" in command) %}
- ErrorString error;
- m_backend->{{command.name}}(&error
- {%- for property in command.parameters -%}
- {%- if "optional" in property -%}
- , in_{{property.name}}
- {%- else -%}
- , {{resolve_type(property).to_pass_type % ("in_" + property.name)}}
- {%- endif -%}
- {%- endfor %}
- {%- if "returns" in command %}
- {%- for property in command.returns -%}
- , &out_{{property.name}}
- {%- endfor %}
- {% endif %});
- {% if "returns" in command and not("async" in command) %}
- if (!error.length()) {
- {% for parameter in command.returns %}
- {% if "optional" in parameter %}
- if (out_{{parameter.name}}.isJust())
- result->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize(out_{{parameter.name}}.fromJust()));
- {% else %}
- result->setValue("{{parameter.name}}", ValueConversions<{{resolve_type(parameter).raw_type}}>::serialize({{resolve_type(parameter).to_raw_type % ("out_" + parameter.name)}}));
- {% endif %}
- {% endfor %}
- }
- if (weak->get())
- weak->get()->sendResponse(callId, error, std::move(result));
- {% else %}
- if (weak->get())
- weak->get()->sendResponse(callId, error);
- {% endif %}
- {%- else %}
- m_backend->{{command.name}}(
- {%- for property in command.parameters -%}
- {%- if "optional" in property -%}
- in_{{property.name}},
- {%- else -%}
- {{resolve_type(property).to_pass_type % ("in_" + property.name)}},
- {%- endif -%}
- {%- endfor -%}
- std::move(callback));
- {% endif %}
-}
- {% endfor %}
-
-// static
-void Dispatcher::wire(UberDispatcher* dispatcher, Backend* backend)
-{
- dispatcher->registerBackend("{{domain.domain}}", wrapUnique(new DispatcherImpl(dispatcher->channel(), backend)));
-}
-
-} // {{domain.domain}}
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/templates/TypeBuilder_h.template b/templates/TypeBuilder_h.template
deleted file mode 100644
index 553ba55..0000000
--- a/templates/TypeBuilder_h.template
+++ /dev/null
@@ -1,290 +0,0 @@
-// This file is generated
-
-// Copyright (c) 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.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_{{domain.domain}}_h
-#define {{"_".join(config.protocol.namespace)}}_{{domain.domain}}_h
-
-{% if config.protocol.export_header %}
-#include {{format_include(config.protocol.export_header)}}
-{% endif %}
-#include "{{config.protocol.package}}/Protocol.h"
-// For each imported domain we generate a ValueConversions struct instead of a full domain definition
-// and include Domain::API version from there.
-{% for name in domain.dependencies %}
-#include "{{config.protocol.package}}/{{name}}.h"
-{% endfor %}
-{% if domain["has_exports"] %}
-#include "{{config.exported.package}}/{{domain.domain}}.h"
-{% endif %}
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-namespace {{domain.domain}} {
-
-// ------------- Forward and enum declarations.
- {% for type in domain.types %}
- {% if type.type == "object" %}
- {% if "properties" in type %}
-// {{type.description}}
-class {{type.id}};
- {% else %}
-// {{type.description}}
-using {{type.id}} = Object;
- {% endif %}
- {% elif type.type != "array" %}
-// {{type.description}}
-using {{type.id}} = {{resolve_type(type).type}};
- {% endif %}
- {% endfor %}
- {% for type in domain.types %}
- {% if "enum" in type %}
-
-namespace {{type.id}}Enum {
- {% for literal in type.enum %}
-{{config.protocol.export_macro}} extern const char* {{ literal | dash_to_camelcase}};
- {% endfor %}
-} // namespace {{type.id}}Enum
- {% endif %}
- {% endfor %}
- {% for command in join_arrays(domain, ["commands", "events"]) %}
- {% for param in join_arrays(command, ["parameters", "returns"]) %}
- {% if "enum" in param %}
-
-namespace {{command.name | to_title_case}} {
-namespace {{param.name | to_title_case}}Enum {
- {% for literal in param.enum %}
-{{config.protocol.export_macro}} extern const char* {{literal | dash_to_camelcase}};
- {% endfor %}
-} // {{param.name | to_title_case}}Enum
-} // {{command.name | to_title_case }}
- {% endif %}
- {% endfor %}
- {% endfor %}
-
-// ------------- Type and builder declarations.
- {% for type in domain.types %}
- {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
- {% set type_def = type_definition(domain.domain + "." + type.id)%}
-
-// {{type.description}}
-class {{config.protocol.export_macro}} {{type.id}} {% if type.exported %}: public API::{{type.id}} {% endif %}{
- PROTOCOL_DISALLOW_COPY({{type.id}});
-public:
- static std::unique_ptr<{{type.id}}> parse(protocol::Value* value, ErrorSupport* errors);
-
- ~{{type.id}}() { }
- {% for property in type.properties %}
- {% if "enum" in property %}
-
- struct {{config.protocol.export_macro}} {{property.name | to_title_case}}Enum {
- {% for literal in property.enum %}
- static const char* {{literal | dash_to_camelcase}};
- {% endfor %}
- }; // {{property.name | to_title_case}}Enum
- {% endif %}
-
- {% if property.optional %}
- bool has{{property.name | to_title_case}}() { return m_{{property.name}}.isJust(); }
- {{resolve_type(property).raw_return_type}} get{{property.name | to_title_case}}({{resolve_type(property).raw_pass_type}} defaultValue) { return m_{{property.name}}.isJust() ? m_{{property.name}}.fromJust() : defaultValue; }
- {% else %}
- {{resolve_type(property).raw_return_type}} get{{property.name | to_title_case}}() { return {{resolve_type(property).to_raw_type % ("m_" + property.name)}}; }
- {% endif %}
- void set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value) { m_{{property.name}} = {{resolve_type(property).to_rvalue % "value"}}; }
- {% endfor %}
-
- std::unique_ptr<protocol::DictionaryValue> serialize() const;
- std::unique_ptr<{{type.id}}> clone() const;
- {% if type.exported %}
- {{config.exported.string_out}} toJSONString() const override;
- {% endif %}
-
- template<int STATE>
- class {{type.id}}Builder {
- public:
- enum {
- NoFieldsSet = 0,
- {% set count = 0 %}
- {% for property in type.properties %}
- {% if not(property.optional) %}
- {% set count = count + 1 %}
- {{property.name | to_title_case}}Set = 1 << {{count}},
- {% endif %}
- {% endfor %}
- AllFieldsSet = (
- {%- for property in type.properties %}
- {% if not(property.optional) %}{{property.name | to_title_case}}Set | {%endif %}
- {% endfor %}0)};
-
- {% for property in type.properties %}
-
- {% if property.optional %}
- {{type.id}}Builder<STATE>& set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value)
- {
- m_result->set{{property.name | to_title_case}}({{resolve_type(property).to_rvalue % "value"}});
- return *this;
- }
- {% else %}
- {{type.id}}Builder<STATE | {{property.name | to_title_case}}Set>& set{{property.name | to_title_case}}({{resolve_type(property).pass_type}} value)
- {
- static_assert(!(STATE & {{property.name | to_title_case}}Set), "property {{property.name}} should not be set yet");
- m_result->set{{property.name | to_title_case}}({{resolve_type(property).to_rvalue % "value"}});
- return castState<{{property.name | to_title_case}}Set>();
- }
- {% endif %}
- {% endfor %}
-
- std::unique_ptr<{{type.id}}> build()
- {
- static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
- return std::move(m_result);
- }
-
- private:
- friend class {{type.id}};
- {{type.id}}Builder() : m_result(new {{type.id}}()) { }
-
- template<int STEP> {{type.id}}Builder<STATE | STEP>& castState()
- {
- return *reinterpret_cast<{{type.id}}Builder<STATE | STEP>*>(this);
- }
-
- {{type_def.type}} m_result;
- };
-
- static {{type.id}}Builder<0> create()
- {
- return {{type.id}}Builder<0>();
- }
-
-private:
- {{type.id}}()
- {
- {% for property in type.properties %}
- {% if not(property.optional) and "default_value" in resolve_type(property) %}
- m_{{property.name}} = {{resolve_type(property).default_value}};
- {%endif %}
- {% endfor %}
- }
-
- {% for property in type.properties %}
- {% if property.optional %}
- Maybe<{{resolve_type(property).raw_type}}> m_{{property.name}};
- {% else %}
- {{resolve_type(property).type}} m_{{property.name}};
- {% endif %}
- {% endfor %}
-};
-
- {% endfor %}
-
-// ------------- Backend interface.
-
-class {{config.protocol.export_macro}} Backend {
-public:
- virtual ~Backend() { }
-
- {% for command in domain.commands %}
- {% if "redirect" in command %}{% continue %}{% endif %}
- {% if ("handlers" in command) and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
- {% if "async" in command %}
- class {{config.protocol.export_macro}} {{command.name | to_title_case}}Callback : public BackendCallback {
- public:
- virtual void sendSuccess(
- {%- for parameter in command.returns -%}
- {%- if "optional" in parameter -%}
- const Maybe<{{resolve_type(parameter).raw_type}}>& {{parameter.name}}
- {%- else -%}
- {{resolve_type(parameter).pass_type}} {{parameter.name}}
- {%- endif -%}
- {%- if not loop.last -%}, {% endif -%}
- {%- endfor -%}
- ) = 0;
- };
- {% endif %}
- virtual void {{command.name}}(
- {%- if not("async" in command) -%}
- ErrorString*
- {%- endif -%}
- {%- for parameter in command.parameters -%}
- {%- if (not loop.first) or not("async" in command) -%}, {% endif -%}
- {%- if "optional" in parameter -%}
- const Maybe<{{resolve_type(parameter).raw_type}}>& in_{{parameter.name}}
- {%- else -%}
- {{resolve_type(parameter).pass_type}} in_{{parameter.name}}
- {%- endif -%}
- {%- endfor -%}
- {%- if "async" in command -%}
- {%- if command.parameters -%}, {% endif -%}
- std::unique_ptr<{{command.name | to_title_case}}Callback> callback
- {%- else -%}
- {%- for parameter in command.returns -%}
- {%- if "optional" in parameter -%}
- , Maybe<{{resolve_type(parameter).raw_type}}>* out_{{parameter.name}}
- {%- else -%}
- , {{resolve_type(parameter).type}}* out_{{parameter.name}}
- {%- endif -%}
- {%- endfor -%}
- {%- endif -%}
- ) = 0;
- {% endfor %}
-
- {% if not has_disable(domain.commands) %}
- virtual void disable(ErrorString*) { }
- {% endif %}
-};
-
-// ------------- Frontend interface.
-
-class {{config.protocol.export_macro}} Frontend {
-public:
- Frontend(FrontendChannel* frontendChannel) : m_frontendChannel(frontendChannel) { }
- {% for event in domain.events %}
- {% if "handlers" in event and not ("renderer" in event["handlers"]) %}{% continue %}{% endif %}
- void {{event.name}}(
- {%- for parameter in event.parameters -%}
- {%- if "optional" in parameter -%}
- const Maybe<{{resolve_type(parameter).raw_type}}>& {{parameter.name}} = Maybe<{{resolve_type(parameter).raw_type}}>()
- {%- else -%}
- {{resolve_type(parameter).pass_type}} {{parameter.name}}
- {%- endif -%}{%- if not loop.last -%}, {% endif -%}
- {%- endfor -%}
- );
- {% endfor %}
-
- void flush();
-private:
- FrontendChannel* m_frontendChannel;
-};
-
-// ------------- Dispatcher.
-
-class {{config.protocol.export_macro}} Dispatcher {
-public:
- static void wire(UberDispatcher*, Backend*);
-
-private:
- Dispatcher() { }
-};
-
-// ------------- Metainfo.
-
-class {{config.protocol.export_macro}} Metainfo {
-public:
- using BackendClass = Backend;
- using FrontendClass = Frontend;
- using DispatcherClass = Dispatcher;
- static const char domainName[];
- static const char commandPrefix[];
- static const char version[];
-};
-
-} // namespace {{domain.domain}}
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_{{domain.domain}}_h)
