DevTools: Promisify Profiler and HeapProfiler domains

third_party/WebKit/Source/devtools/scripts/build/generate_protocol_externs.py

 #!/usr/bin/env python
 # Copyright (c) 2011 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 28 matching lines @@
     "string": "string",
     "integer": "number",
     "number": "number",
     "boolean": "boolean",
     "array": "!Array<*>",
     "object": "!Object",
 }
 
 ref_types = {}
 
+PROMISIFIED_DOMAINS = frozenset([
+    "HeapProfiler",
+    "Profiler",
+])
+
 
 def full_qualified_type_id(domain_name, type_id):
     if type_id.find(".") == -1:
         return "%s.%s" % (domain_name, type_id)
     return type_id
 
 
 def fix_camel_case(name):
     prefix = ""
     if name[0] == "-":
@@ skipping 51 matching lines @@
 
     for domain in domains:
         domain_name = domain["domain"]
         if "types" in domain:
             for type in domain["types"]:
                 type_id = full_qualified_type_id(domain_name, type["id"])
                 ref_types[type_id] = "Protocol.%s.%s" % (domain_name, type["id"])
 
     for domain in domains:
         domain_name = domain["domain"]
+        is_promisified = domain_name in PROMISIFIED_DOMAINS
 
         output_file.write("Protocol.%s = {};\n" % domain_name)
         output_file.write("\n\n/**\n * @constructor\n*/\n")
         output_file.write("Protocol.%sAgent = function(){};\n" % domain_name)
 
         if "commands" in domain:
             for command in domain["commands"]:
                 output_file.write("\n/**\n")
                 params = []
                 in_param_to_type = {}
@@ skipping 15 matching lines @@
                 if ("error" in command):
                     returns.append("%s=" % param_type(domain_name, command["error"]))
                 if (has_return_value):
                     for out_param in command["returns"]:
                         out_param_type = param_type(domain_name, out_param)
                         out_param_to_type[out_param["name"]] = out_param_type
                         if ("optional" in out_param):
                             returns.append("%s=" % out_param_type)
                         else:
                             returns.append("%s" % out_param_type)
-                output_file.write(" * @param {function(%s):T=} opt_callback\n" % ", ".join(returns))
-                output_file.write(" * @return {!Promise<T>}\n")
-                output_file.write(" * @template T\n")
-                params.append("opt_callback")
+
+                if is_promisified:
+                    if has_return_value and len(command["returns"]) > 0:
+                        out_param_type = param_type(domain_name, command["returns"][0])
+                        if re.match(r"^[!?]", out_param_type[:1]):
+                            out_param_type = out_param_type[1:]
+                        out_param_type = "?%s" % out_param_type
+                    else:
+                        out_param_type = "undefined"
+                    output_file.write(" * @return {!Promise<%s>}\n" % out_param_type)
+                else:
+                    output_file.write(" * @param {function(%s):T=} opt_callback\n" % ", ".join(returns))
+                    output_file.write(" * @return {!Promise<T>}\n")
+                    output_file.write(" * @template T\n")
+                    params.append("opt_callback")
 
                 output_file.write(" */\n")
                 output_file.write("Protocol.%sAgent.prototype.%s = function(%s) {};\n" %
                                   (domain_name, command["name"], ", ".join(params)))
 
                 request_object_properties = []
+                request_type = "Protocol.%sAgent.%sRequest" % (domain_name, to_title_case(command["name"]))
                 for param in in_param_to_type:
                     request_object_properties.append("%s: %s" % (param, in_param_to_type[param]))
                 if request_object_properties:
                     output_file.write("/** @typedef {!{%s}} */\n" % (", ".join(request_object_properties)))
                 else:
                     output_file.write("/** @typedef {Object|undefined} */\n")
-                request = "Protocol.%sAgent.%sRequest" % (domain_name, to_title_case(command["name"]))
-                output_file.write("%s;\n" % request)
+                output_file.write("%s;\n" % request_type)
 
                 response_object_properties = []
+                response_type = "Protocol.%sAgent.%sResponse" % (domain_name, to_title_case(command["name"]))
                 for param in out_param_to_type:
                     response_object_properties.append("%s: %s" % (param, out_param_to_type[param]))
                 if response_object_properties:
                     output_file.write("/** @typedef {!{%s}} */\n" % (", ".join(response_object_properties)))
                 else:
                     output_file.write("/** @typedef {Object|undefined} */\n")
-                response = "Protocol.%sAgent.%sResponse" % (domain_name, to_title_case(command["name"]))
-                output_file.write("%s;\n" % response)
+                output_file.write("%s;\n" % response_type)
 
                 output_file.write("/**\n")
-                output_file.write(" * @param {!%s} obj\n" % request)
-                output_file.write(" * @return {!Promise<!%s>}" % response)
+                output_file.write(" * @param {!%s} obj\n" % request_type)
+                output_file.write(" * @return {!Promise<!%s>}" % response_type)
                 output_file.write(" */\n")
                 output_file.write("Protocol.%sAgent.prototype.invoke_%s = function(obj) {};\n" %
                                   (domain_name, command["name"]))
 
         if "types" in domain:
             for type in domain["types"]:
                 if type["type"] == "object":
                     typedef_args = []
                     if "properties" in type:
                         for property in type["properties"]:
@@ skipping 58 matching lines @@
     import sys
     import os.path
     program_name = os.path.basename(__file__)
     if len(sys.argv) < 5 or sys.argv[1] != "-o":
         sys.stderr.write("Usage: %s -o OUTPUT_FILE INPUT_FILE_1 INPUT_FILE_2\n" % program_name)
         exit(1)
     output_path = sys.argv[2]
     input_path_1 = sys.argv[3]
     input_path_2 = sys.argv[4]
     generate_protocol_externs(output_path, input_path_1, input_path_2)