DevTools: generate class-per domain for remote debugging protocol.

third_party/WebKit/Source/platform/inspector_protocol/CodeGenerator.py

 # 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 string
 import optparse
 import re
 try:
@@ skipping 15 matching lines @@
     module_path, os.pardir, os.pardir, os.pardir, os.pardir))
 
 # jinja2 is in chromium's third_party directory.
 # Insert at 1 so at front to override system libraries, and
 # after path[0] == invoking script dir
 
 sys.path.insert(1, third_party_dir)
 import jinja2
 
 cmdline_parser = optparse.OptionParser()
+cmdline_parser.add_option("--domains")
 cmdline_parser.add_option("--output_dir")
-cmdline_parser.add_option("--generate_dispatcher")
+cmdline_parser.add_option("--output_package")
+cmdline_parser.add_option("--string_type")
+cmdline_parser.add_option("--export_macro")
+
+generate_domains = set()
 
 try:
     arg_options, arg_values = cmdline_parser.parse_args()
     if (len(arg_values) == 0):
         raise Exception("At least one plain argument expected (found %s)" % len(arg_values))
     output_dirname = arg_options.output_dir
-    generate_dispatcher = arg_options.generate_dispatcher
     if not output_dirname:
         raise Exception("Output directory must be specified")
+    output_package = arg_options.output_package
+    if not output_package:
+        raise Exception("Output package must be specified")
+    string_type = arg_options.string_type
+    if not string_type:
+        raise Exception("String type must be specified")
+    export_macro = arg_options.export_macro
+    if not export_macro:
+        raise Exception("Export macro must be specified")
+    output_domains = arg_options.domains
+    if output_domains and len(output_domains):
+        for domain in output_domains.split(","):
+            generate_domains.add(domain)
 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)
-    sys.stderr.write("Usage: <script> --output_dir <output_dir> blink_protocol.json v8_protocol.json ...\n")
+    sys.stderr.write("Usage: <script> --output_dir <output_dir> protocol.json ...\n")
     exit(1)
 
 json_api = {"domains": []}
 
 json_timestamp = 0
 
 for filename in arg_values:
     json_timestamp = max(os.path.getmtime(filename), json_timestamp)
     input_file = open(filename, "r")
     json_string = input_file.read()
@@ skipping 19 matching lines @@
         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 output_file(file_name):
     return open(file_name, "w")
 
 
-def topsort_domains():
-    domains = {}
-    for domain in json_api["domains"]:
-        domains[domain["domain"]] = domain
-
-    processed = set()
-    result = []
-
-    def process(name):
-        if name in processed:
-            return
-        domain = domains[name]
-        deps = []
-        if "depends" in domain:
-            for dep in domain["depends"]:
-                process(dep)
-        result.append(domain)
-        processed.add(name)
-
-    for domain in json_api["domains"]:
-        process(domain["domain"])
-    json_api["domains"] = result
-
-
 def patch_full_qualified_refs():
     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":
@@ skipping 44 matching lines @@
         "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(domain):
-    if domain in ["Runtime", "Debugger", "Profiler", "HeapProfiler"]:
-        return {
-            "return_type": "String16",
-            "pass_type": "const String16&",
-            "to_pass_type": "%s",
-            "to_raw_type": "%s",
-            "to_rvalue": "%s",
-            "type": "String16",
-            "raw_type": "String16",
-            "raw_pass_type": "const String16&",
-            "raw_return_type": "String16",
-        }
     return {
-        "return_type": "String",
-        "pass_type": "const String&",
+        "return_type": string_type,
+        "pass_type": ("const %s&" % string_type),
         "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",
+        "type": string_type,
+        "raw_type": string_type,
+        "raw_pass_type": ("const %s&" % string_type),
+        "raw_return_type": string_type,
     }
 
 
 def create_primitive_type_definition(type):
     typedefs = {
         "number": "double",
         "integer": "int",
         "boolean": "bool"
     }
     jsontypes = {
@@ skipping 45 matching lines @@
             if type["type"] == "object":
                 type_definitions[domain["domain"] + "." + type["id"]] = create_user_type_definition(domain["domain"], type)
             elif type["type"] == "array":
                 items_type = type["items"]["type"]
                 type_definitions[domain["domain"] + "." + type["id"]] = wrap_array_definition(type_definitions[items_type])
             elif type["type"] == domain["domain"] + ".string":
                 type_definitions[domain["domain"] + "." + type["id"]] = create_string_type_definition(domain["domain"])
             else:
                 type_definitions[domain["domain"] + "." + type["id"]] = create_primitive_type_definition(type["type"])
 
-topsort_domains()
 patch_full_qualified_refs()
 create_type_definitions()
 
 
 def type_definition(name):
     return type_definitions[name]
 
 
 def resolve_type(property):
     if "$ref" in property:
@@ skipping 24 matching lines @@
     current_script_timestamp = 0
 
 
 def is_up_to_date(file, template):
     if not os.path.exists(file):
         return False
     timestamp = os.path.getmtime(file)
     return timestamp > max(os.path.getmtime(module_path + template),
                            current_script_timestamp, json_timestamp)
 
+if not os.path.exists(output_dirname):
+    os.mkdir(output_dirname)
+jinja_env = initialize_jinja_env(output_dirname)
 
-def generate(class_name):
-    h_template_name = "/%s_h.template" % class_name
-    cpp_template_name = "/%s_cpp.template" % class_name
+h_template_name = "/TypeBuilder_h.template"
+cpp_template_name = "/TypeBuilder_cpp.template"
+h_template = jinja_env.get_template(h_template_name)
+cpp_template = jinja_env.get_template(cpp_template_name)
+
+
+def generate(domain):
+    class_name = domain["domain"]
     h_file_name = output_dirname + "/" + class_name + ".h"
     cpp_file_name = output_dirname + "/" + class_name + ".cpp"
 
     if (is_up_to_date(cpp_file_name, cpp_template_name) and
             is_up_to_date(h_file_name, h_template_name)):
         return
 
     template_context = {
-        "class_name": class_name,
-        "api": json_api,
+        "domain": domain,
         "join_arrays": join_arrays,
         "resolve_type": resolve_type,
         "type_definition": type_definition,
-        "has_disable": has_disable
+        "has_disable": has_disable,
+        "export_macro": export_macro,
+        "output_package": output_package,
     }
-    h_template = jinja_env.get_template(h_template_name)
-    cpp_template = jinja_env.get_template(cpp_template_name)
     h_file = output_file(h_file_name)
     cpp_file = output_file(cpp_file_name)
     h_file.write(h_template.render(template_context))
     cpp_file.write(cpp_template.render(template_context))
     h_file.close()
     cpp_file.close()
 
 
-jinja_env = initialize_jinja_env(output_dirname)
-generate("TypeBuilder")
+for domain in json_api["domains"]:
+    if domain["domain"] in generate_domains:
+        generate(domain)