[DevTools] Roll third_party/inspector_protocol to 3c6f5ff8ab6653b47cf226233d488701a527d761.

third_party/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 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
-    return False
+def entity_options(protocol, config, domain, entity, entity_name):
+    def update(generate, async, rule, property, suffix):
+        if not hasattr(rule, property):
+            return generate, async
+        value = getattr(rule, property)
+        if value == "+" + suffix:
+            generate = True
+            if hasattr(rule, "async"):
+                async = getattr(rule, "async")
+        if value == "-" + suffix:
+            generate = False
+        return generate, async
+
+    if not config.protocol.options:
+        return (domain in protocol.generate_domain, False)
+
+    generate, async = False, False
+    for rule in config.protocol.options:
+        generate, async = update(generate, async, rule, "domain", domain)
+        generate, async = update(generate, async, rule, entity, domain + "." + entity_name)
+    return generate, async
+
+
+def generate_command(protocol, config, domain, command):
+    generate, _ = entity_options(protocol, config, domain, "command", command)
+    return generate
+
+
+def generate_event(protocol, config, domain, event):
+    generate, _ = entity_options(protocol, config, domain, "event", event)
+    return generate
+
+
+def is_async_command(protocol, config, domain, command):
+    _, async = entity_options(protocol, config, domain, "command", command)
+    return async
+
+
+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()
@@ skipping 57 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()