Support config.protocol.options which defines which part of protocol definition should be generated.

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 64 matching lines @@
         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,
+            ".protocol.options": 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
@@ skipping 235 matching lines @@
 
 
 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" and (not ("handlers" in command) or "renderer" in command["handlers"]):
-            return True
+def generate_command(protocol, config, domain, command):
+    if not config.protocol.options:
+        return domain in protocol.generate_domains
+    for rule in config.protocol.options:
+        if rule.domain != domain:
+            continue
+        if hasattr(rule, "include"):
+            return command in rule.include
+        if hasattr(rule, "exclude"):
+            return command not in rule.exclude
+        return True
     return False
 
 
+def generate_event(protocol, config, domain, event):
+    if not config.protocol.options:
+        return domain in protocol.generate_domains
+    for rule in config.protocol.options:
+        if rule.domain != domain:
+            continue
+        if hasattr(rule, "include_events"):
+            return event in rule.include_events
+        if hasattr(rule, "exclude_events"):
+            return event not in rule.exclude_events
+        return True
+    return False
+
+
+def is_async_command(protocol, config, domain, command):
+    if not config.protocol.options:
+        return False
+    for rule in config.protocol.options:
+        if rule.domain != domain:
+            continue
+        if hasattr(rule, "async"):
+            return command in rule.async
+        return False
+    return False
+
+
+def generate_disable(protocol, config, domain):
+    if "commands" not in domain:
+        return True
+    for command in domain["commands"]:
+        if command["name"] == "disable" and generate_command(protocol, config, domain["domain"], "disable"):
+            return False
+    return True
+
+
 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"]
@@ skipping 55 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,
+            "generate_command": functools.partial(generate_command, protocol, config),
+            "generate_event": functools.partial(generate_event, protocol, config),
+            "is_async_command": functools.partial(is_async_command, protocol, config),
+            "generate_disable": functools.partial(generate_disable, protocol, config),
             "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)
@@ skipping 56 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()