[DevTools] Various tweaks to 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
 import collections
 import functools
 try:
@@ skipping 14 matching lines @@
 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)
-        keys = list(config_partial._fields)  # pylint: disable=E1101
-        values = [getattr(config_partial, k) for k in keys]
-        for optional in ["imported", "exported", "lib"]:
-            if optional not in keys:
-                keys.append(optional)
-                values.append(False)
         config_json_file.close()
-        return (jinja_dir, config_file, collections.namedtuple('X', keys)(*values))
+        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:]
 
@@ skipping 234 matching lines @@
     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
@@ skipping 51 matching lines @@
     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
+            "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
+            "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",
@@ skipping 42 matching lines @@
     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()