DevTools: consolidate protocol generators for front-end, backend and type builder.

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 70 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 131 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:
         return type_definitions[property["$ref"]]
     if property["type"] == "array":
         return wrap_array_definition(resolve_type(property["items"]))
     return type_definitions[property["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
+
+
 if os.path.exists(__file__):
     current_script_timestamp = os.path.getmtime(__file__)
 else:
     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)
 
 
 def generate(class_name):
     h_template_name = "/%s_h.template" % class_name
     cpp_template_name = "/%s_cpp.template" % class_name
     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,
         "join_arrays": join_arrays,
         "resolve_type": resolve_type,
-        "type_definition": type_definition
+        "type_definition": type_definition,
+        "has_disable": has_disable
     }
     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("Backend")
-generate("Dispatcher")
-generate("Frontend")
 generate("TypeBuilder")