Roll third_party/inspector_protocol to 4ad35c45aca9834b67ec2cb152c816ea1b7ceb48

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
 import re
+import copy
 try:
     import json
 except ImportError:
     import simplejson as json
 
 # Path handling for libraries and templates
 # Paths have to be normalized because Jinja uses the exact template path to
 # determine the hash used in the cache filename, and we need a pre-caching step
 # to be concurrency-safe. Use absolute path because __file__ is absolute if
 # module is imported, and relative if executed directly.
@@ skipping 177 matching lines @@
         domain = domain_json["domain"]
         clear = domain not in exported_domains and domain not in imported_domains
         if not has_exports(domain_json, clear):
             continue
         if domain in exported_domains:
             protocol.exported_domains.append(domain)
         if domain in imported_domains:
             protocol.imported_domains.append(domain)
 
 
-def create_imported_type_definition(domain_name, type, imported_namespace):
+def create_imported_type_definition(domain_name, type_id, imported_namespace):
     # pylint: disable=W0622
     return {
-        "return_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
-        "pass_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
+        "return_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type_id),
+        "pass_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type_id),
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
         "to_rvalue": "std::move(%s)",
-        "type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
-        "raw_type": "%s::%s::API::%s" % (imported_namespace, domain_name, type["id"]),
-        "raw_pass_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type["id"]),
-        "raw_return_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type["id"]),
+        "type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type_id),
+        "raw_type": "%s::%s::API::%s" % (imported_namespace, domain_name, type_id),
+        "raw_pass_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type_id),
+        "raw_return_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type_id),
     }
 
 
-def create_user_type_definition(domain_name, type):
+def create_user_type_definition(domain_name, type_id):
     # pylint: disable=W0622
     return {
-        "return_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
-        "pass_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
+        "return_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type_id),
+        "pass_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type_id),
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
         "to_rvalue": "std::move(%s)",
-        "type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
-        "raw_type": "protocol::%s::%s" % (domain_name, type["id"]),
-        "raw_pass_type": "protocol::%s::%s*" % (domain_name, type["id"]),
-        "raw_return_type": "protocol::%s::%s*" % (domain_name, type["id"]),
+        "type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type_id),
+        "raw_type": "protocol::%s::%s" % (domain_name, type_id),
+        "raw_pass_type": "protocol::%s::%s*" % (domain_name, type_id),
+        "raw_return_type": "protocol::%s::%s*" % (domain_name, type_id),
     }
 
 
 def create_object_type_definition():
     # pylint: disable=W0622
     return {
         "return_type": "std::unique_ptr<protocol::DictionaryValue>",
         "pass_type": "std::unique_ptr<protocol::DictionaryValue>",
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
@@ skipping 84 matching lines @@
 
 def create_type_definitions(protocol, imported_namespace):
     protocol.type_definitions = {}
     protocol.type_definitions["number"] = create_primitive_type_definition("number")
     protocol.type_definitions["integer"] = create_primitive_type_definition("integer")
     protocol.type_definitions["boolean"] = create_primitive_type_definition("boolean")
     protocol.type_definitions["object"] = create_object_type_definition()
     protocol.type_definitions["any"] = create_any_type_definition()
     for domain in protocol.json_api["domains"]:
         protocol.type_definitions[domain["domain"] + ".string"] = create_string_type_definition()
-        if not ("types" in domain):
-            continue
-        for type in domain["types"]:
+        for type in domain["types"] if "types" in domain else []:

[dgozman, 2016/11/21 22:29:16]

Advanced python right here!

             type_name = domain["domain"] + "." + type["id"]
             if type["type"] == "object" and domain["domain"] in protocol.imported_domains:
-                protocol.type_definitions[type_name] = create_imported_type_definition(domain["domain"], type, imported_namespace)
+                protocol.type_definitions[type_name] = create_imported_type_definition(domain["domain"], type["id"], imported_namespace)
             elif type["type"] == "object":
-                protocol.type_definitions[type_name] = create_user_type_definition(domain["domain"], type)
+                protocol.type_definitions[type_name] = create_user_type_definition(domain["domain"], type["id"])
             elif type["type"] == "array":
                 items_type = type["items"]["type"]
                 protocol.type_definitions[type_name] = wrap_array_definition(protocol.type_definitions[items_type])
             elif type["type"] == domain["domain"] + ".string":
                 protocol.type_definitions[type_name] = create_string_type_definition()
             else:
                 protocol.type_definitions[type_name] = create_primitive_type_definition(type["type"])
-
+        for event in domain["events"] if "events" in domain else []:
+            type_id = to_title_case(event["name"]) + "Notification"
+            type_name = domain["domain"] + "." + type_id
+            if domain["domain"] in protocol.imported_domains:
+                protocol.type_definitions[type_name] = create_imported_type_definition(domain["domain"], type_id, imported_namespace)
+            else:
+                protocol.type_definitions[type_name] = create_user_type_definition(domain["domain"], type_id)
 
 def type_definition(protocol, name):
     return protocol.type_definitions[name]
 
 
 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"]))
@@ skipping 129 matching lines @@
 
     h_template = jinja_env.get_template("templates/TypeBuilder_h.template")
     cpp_template = jinja_env.get_template("templates/TypeBuilder_cpp.template")
     exported_template = jinja_env.get_template("templates/Exported_h.template")
     imported_template = jinja_env.get_template("templates/Imported_h.template")
 
     outputs = dict()
 
     for domain in protocol.json_api["domains"]:
         class_name = domain["domain"]
+        if "events" in domain:
+            for event in domain["events"]:
+                event_type = dict()
+                event_type["description"] = "Wrapper for notification params"
+                event_type["type"] = "object"
+                event_type["id"] = to_title_case(event["name"]) + "Notification"
+                if "parameters" in event:
+                    event_type["properties"] = copy.deepcopy(event["parameters"])
+                if "types" not in domain:
+                    domain["types"] = list()
+                domain["types"].append(event_type)
+
         template_context = {
             "config": config,
             "domain": domain,
             "join_arrays": join_arrays,
             "resolve_type": functools.partial(resolve_type, protocol),
             "type_definition": functools.partial(type_definition, protocol),
             "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),
@@ skipping 66 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()