Roll third_party/inspector_protocol to cf45a6e89b17cdc9eeacdef4c003fcc55f7ec2a0

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 311 matching lines @@
 
 
 def resolve_type(protocol, prop):
     if "$ref" in prop:
         return protocol.type_definitions[prop["$ref"]]
     if prop["type"] == "array":
         return wrap_array_definition(resolve_type(protocol, prop["items"]))
     return protocol.type_definitions[prop["type"]]
 
 
+def new_style(domain):
+    domains = []
+    return domain["domain"] in domains
+
+
 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":
+        if command["name"] == "disable" and (not ("handlers" in command) or "renderer" in command["handlers"]):
             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")
@@ skipping 61 matching lines @@
     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,
             "format_include": format_include,
+            "new_style": new_style,
         }
 
         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,
             "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",
             "ValueConversions_h.template",
             "Maybe_h.template",
             "Array_h.template",
-            "BackendCallback_h.template",
             "DispatcherBase_h.template",
             "Parser_h.template",
         ]
 
         lib_cpp_templates = [
             "Protocol_cpp.template",
             "ErrorSupport_cpp.template",
             "Values_cpp.template",
             "Object_cpp.template",
             "DispatcherBase_cpp.template",
@@ skipping 28 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()