DevTools: [CSS] promisify CSS domain

Source/devtools/scripts/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 22 matching lines @@
     "any": "*",
     "string": "string",
     "integer": "number",
     "number": "number",
     "boolean": "boolean",
     "array": "!Array.<*>",
     "object": "!Object",
 }
 
 promisified_domains = {
-    "Profiler"
+    "Profiler",
+    "CSS"
 }
 
 ref_types = {}
 
 def full_qualified_type_id(domain_name, type_id):
     if type_id.find(".") == -1:
         return "%s.%s" % (domain_name, type_id)
     return type_id
 
 
@@ skipping 59 matching lines @@
         domain_name = domain["domain"]
         promisified = domain_name in promisified_domains
 
         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 = []
+                has_return_value = "returns" in command
+                explicit_parameters = promisified and has_return_value
                 if ("parameters" in command):
                     for in_param in command["parameters"]:
-                        if ("optional" in in_param):
+                        # All parameters are not optional in case of promisified domain with return value.
+                        if (not explicit_parameters and "optional" in in_param):
                             params.append("opt_%s" % in_param["name"])
                             output_file.write(" * @param {%s=} opt_%s\n" % (param_type(domain_name, in_param), in_param["name"]))
                         else:
                             params.append(in_param["name"])
                             output_file.write(" * @param {%s} %s\n" % (param_type(domain_name, in_param), in_param["name"]))
                 returns = []
-                if (not promisified):
-                    returns.append("?Protocol.Error")
-                    if ("error" in command):
-                        returns.append("%s=" % param_type(domain_name, command["error"]))
-                if ("returns" in command):
+                returns.append("?Protocol.Error")
+                if ("error" in command):
+                    returns.append("%s=" % param_type(domain_name, command["error"]))
+                if (has_return_value):
                     for out_param in command["returns"]:
                         if ("optional" in out_param):
                             returns.append("%s=" % param_type(domain_name, out_param))
                         else:
                             returns.append("%s" % param_type(domain_name, out_param))
+                callback_return_type = "void="
+                if explicit_parameters:
+                    callback_return_type = "T"
+                elif promisified:
+                    callback_return_type = "T="
+                output_file.write(" * @param {function(%s):%s} opt_callback\n" % (", ".join(returns), callback_return_type))
                 if (promisified):
-                    returns_len = len(command["returns"]) if "returns" in command else 0
-                    if returns_len == 0:
-                        output_file.write(" * @return {!Promise.<undefined>}\n")
-                    else:
-                        promise_returns = []
-                        for out_param in command["returns"]:
-                            type = param_type(domain_name, out_param)
-                            if "optional" in out_param:
-                                type = "(%s|undefined)" % type
-                            promise_returns.append("%s: %s" % (out_param["name"], type))
-                        output_file.write(" * @return {!Promise.<!{%s}>}\n" % ", ".join(promise_returns))
-                else:
-                    output_file.write(" * @param {function(%s):void=} opt_callback\n" % ", ".join(returns))
-                    params.append("opt_callback")
+                    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)))
                 output_file.write("/** @param {function(%s):void=} opt_callback */\n" % ", ".join(returns))
                 output_file.write("Protocol.%sAgent.prototype.invoke_%s = function(obj, opt_callback) {}\n" % (domain_name, command["name"]))
 
         output_file.write("\n\n\nvar %sAgent = {};\n" % domain_name)
 
         if "types" in domain:
             for type in domain["types"]:
                 if type["type"] == "object":
@@ skipping 59 matching lines @@
 if __name__ == "__main__":
     import sys
     import os.path
     program_name = os.path.basename(__file__)
     if len(sys.argv) < 4 or sys.argv[1] != "-o":
         sys.stderr.write("Usage: %s -o OUTPUT_FILE INPUT_FILE\n" % program_name)
         exit(1)
     output_path = sys.argv[2]
     input_path = sys.argv[3]
     generate_protocol_externs(output_path, input_path)