[DevTools] Generate all files in inspector_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 optparse
 try:
     import json
 except ImportError:
@@ skipping 88 matching lines @@
     if "export" in config:
         exporting = True
         exported_dirname = config["export"]["output"]
         if not exported_dirname:
             raise Exception("Config is missing export.output")
         exported_dirname = os.path.join(output_base, exported_dirname)
         exported_package = config["export"]["package"]
         if not exported_package:
             raise Exception("Config is missing export.package")
 
+    lib = False
+    if "lib" in config:
+        lib = True
+        lib_dirname = config["lib"]["output"]
+        if not lib_dirname:
+            raise Exception("Config is missing lib.output")
+        lib_dirname = os.path.join(output_base, lib_dirname)
+        lib_string16_include = config["lib"]["string16_impl_header_path"]
+        if not lib_string16_include:
+            raise Exception("Config is missing lib.string16_impl_header_path")
+        lib_platform_include = config["lib"]["platform_impl_header_path"]
+        if not lib_platform_include:
+            raise Exception("Config is missing lib.platform_impl_header_path")
+
     string_type = config["string"]["class_name"]
     if not string_type:
         raise Exception("Config is missing string.class_name")
 
-    export_macro = config["export_macro"]
+    export_macro = config["class_export"]["macro"]
     if not export_macro:
-        raise Exception("Config is missing export_macro")
+        raise Exception("Config is missing class_export.macro")
+    export_macro_include = config["class_export"]["header_path"]
+    if not export_macro_include:
+        raise Exception("Config is missing class_export.header_path")
+
+    lib_package = config["lib_package"]
+    if not lib_package:
+        raise Exception("Config is missing lib_package")
 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)
 
 
 # Make gyp / make generatos happy, otherwise make rebuilds world.
 def up_to_date():
     template_ts = max(
@@ skipping 271 matching lines @@
     return result
 
 
 def has_disable(commands):
     for command in commands:
         if command["name"] == "disable":
             return True
     return False
 
 
-def generate_with_context(template_context, template, file_name):
-    out_file = output_file(file_name)
-    out_file.write(template.render(template_context))
-    out_file.close()
-
-
 def generate(domain_object, template, file_name):
     template_context = {
         "domain": domain_object,
         "join_arrays": join_arrays,
         "resolve_type": resolve_type,
         "type_definition": type_definition,
         "has_disable": has_disable,
         "export_macro": export_macro,
-        "output_package": output_package
+        "export_macro_include": export_macro_include,
+        "output_package": output_package,
+        "lib_package": lib_package
     }
     if exporting:
         template_context["exported_package"] = exported_package
     if importing:
         template_context["imported_package"] = imported_package
-    generate_with_context(template_context, template, file_name)
+    out_file = output_file(file_name)
+    out_file.write(template.render(template_context))
+    out_file.close()
 
 
 def read_protocol_file(file_name, all_domains):
     input_file = open(file_name, "r")
     json_string = input_file.read()
     parsed_json = json.loads(json_string)
     domains = []
     for domain in parsed_json["domains"]:
         domains.append(domain["domain"])
     all_domains["domains"] += parsed_json["domains"]
     return domains
 
 
+def generate_lib():
+    template_context = {
+        "string16_impl_h_include": lib_string16_include,
+        "platform_impl_h_include": lib_platform_include,
+        "lib_package": lib_package,
+        "export_macro": export_macro,
+        "export_macro_include": export_macro_include
+    }
+
+    def generate_file(file_name, template_files):
+        out_file = output_file(file_name)
+        for template_file in template_files:
+            template = jinja_env.get_template("/" + template_file)
+            out_file.write(template.render(template_context))
+            out_file.write("\n\n")
+        out_file.close()
+
+    # Note these should be sorted in the right order.
+    # TODO(dgozman): sort them programmatically based on commented includes.
+    lib_h_templates = [
+        "Allocator_h.template",
+        "Platform_h.template",
+        "Collections_h.template",
+        "String16_h.template",
+
+        "ErrorSupport_h.template",
+        "Values_h.template",
+        "Object_h.template",
+        "ValueConversions_h.template",
+        "Maybe_h.template",
+        "Array_h.template",
+
+        "FrontendChannel_h.template",
+        "BackendCallback_h.template",
+        "DispatcherBase_h.template",
+
+        "Parser_h.template",
+    ]
+
+    lib_cpp_templates = [
+        "InspectorProtocol_cpp.template",
+
+        "String16_cpp.template",
+
+        "ErrorSupport_cpp.template",
+        "Values_cpp.template",
+        "Object_cpp.template",
+
+        "DispatcherBase_cpp.template",
+
+        "Parser_cpp.template",
+    ]
+
+    generate_file(os.path.join(lib_dirname, "InspectorProtocol.h"), lib_h_templates)
+    generate_file(os.path.join(lib_dirname, "InspectorProtocol.cpp"), lib_cpp_templates)
+
+
 json_api = {"domains": []}
 generate_domains = read_protocol_file(protocol_file, json_api)
 imported_domains = read_protocol_file(imported_file, json_api) if importing else []
 patch_full_qualified_refs()
 calculate_exports()
 create_type_definitions()
 
 if up_to_date():
     sys.exit()
 if not os.path.exists(output_dirname):
     os.mkdir(output_dirname)
 if json_api["has_exports"] and not os.path.exists(exported_dirname):
     os.mkdir(exported_dirname)
 
 jinja_env = initialize_jinja_env(output_dirname)
 h_template = jinja_env.get_template("/TypeBuilder_h.template")
 cpp_template = jinja_env.get_template("/TypeBuilder_cpp.template")
 exported_template = jinja_env.get_template("/Exported_h.template")
 imported_template = jinja_env.get_template("/Imported_h.template")
 
 for domain in json_api["domains"]:
     class_name = domain["domain"]
     if domain["domain"] in generate_domains:
         generate(domain, h_template, os.path.join(output_dirname, class_name + ".h"))
         generate(domain, cpp_template, os.path.join(output_dirname, class_name + ".cpp"))
         if domain["has_exports"]:
             generate(domain, exported_template, os.path.join(exported_dirname, class_name + ".h"))
     if domain["domain"] in imported_domains and domain["has_exports"]:
         generate(domain, imported_template, os.path.join(output_dirname, class_name + ".h"))
+
+if lib:
+    generate_lib()