[DevTools] Support redirects in protocol handler generator.

content/browser/devtools/protocol/devtools_protocol_handler_generator.py

 #!/usr/bin/env python
 # Copyright 2014 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 sys
 import string
 import json
 
 blink_protocol_path = sys.argv[1]
@@ skipping 293 matching lines @@
     devtools::${domain}::${Domain}Handler* ${domain}_handler) {
   DCHECK(!${domain}_handler_);
   ${domain}_handler_ = ${domain}_handler;
 ${initializations}\
 }
 """)
 
 tmpl_register = string.Template("""\
   command_handlers_["${Domain}.${command}"] =
       base::Bind(
-          &DevToolsProtocolDispatcher::On${Domain}${Command},
+          &DevToolsProtocolDispatcher::On${TargetDomain}${Command},
           base::Unretained(this));
 """)
 
 tmpl_init_client = string.Template("""\
   ${domain}_handler_->SetClient(make_scoped_ptr(
       new devtools::${domain}::Client(notifier_)));
 """)
 
 tmpl_callback_impl = string.Template("""\
 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
@@ skipping 118 matching lines @@
       result += c
   return result
 
 types = {}
 blink_protocol = json.loads(open(blink_protocol_path, "r").read())
 browser_protocol = json.loads(open(browser_protocol_path, "r").read())
 type_decls = []
 type_impls = []
 handler_methods = []
 handler_method_impls = []
+domain_maps = []
+redirects = {}
 
 all_domains = blink_protocol["domains"] + browser_protocol["domains"]
 
 for json_domain in all_domains:
   if "types" in json_domain:
     for json_type in json_domain["types"]:
       types["%s.%s" % (json_domain["domain"], json_type["id"])] = json_type
 
 def DeclareStruct(json_properties, mapping):
   methods = []
@@ skipping 168 matching lines @@
     for json_command in json_domain["commands"]:
       if (not ("handlers" in json_command) or
           not ("browser" in json_command["handlers"])):
         continue
       domain_empty = False
 
       command_map = domain_map.copy()
       command_map["command"] = json_command["name"]
       command_map["Command"] = Capitalize(json_command["name"])
 
+      if "redirect" in json_command:
+        redirect_domain = json_command["redirect"]
+        if not (redirect_domain in redirects):
+          redirects[redirect_domain] = []
+        command_map["TargetDomain"] = redirect_domain
+        redirects[redirect_domain].append(tmpl_register.substitute(command_map))
+        continue
+
+      command_map["TargetDomain"] = json_domain["domain"]

[dgozman, 2015/03/18 17:30:11]

I'd rather do
command_map["TargetDomain"] = command_map["Domain"]

[vkuzkokov, 2015/03/18 17:34:10]

Done.

       prep = []
       args = []
 
       if "parameters" in json_command:
         for json_param in json_command["parameters"]:
           param_map = command_map.copy()
           param_map["proto_param"] = json_param["name"]
           param_map["param"] = Uncamelcase(json_param["name"])
           ResolveType(json_param, param_map)
           if json_param.get("optional"):
@@ skipping 77 matching lines @@
   setters.append(tmpl_setter.substitute(domain_map))
   fields.append(tmpl_field.substitute(domain_map))
   includes.append(tmpl_include.substitute(domain_map))
   fields_init.append(tmpl_field_init.substitute(domain_map))
   if domain_needs_client:
     type_decls.append(tmpl_client.substitute(domain_map,
         methods = "".join(client_methods)))
     initializations.append(tmpl_init_client.substitute(domain_map))
     type_impls.append(tmpl_client_impl.substitute(domain_map,
         methods = "\n".join(client_method_impls)))
-  handler_method_impls.append(tmpl_setter_impl.substitute(domain_map,
-      initializations = "".join(initializations)))
+  domain_map["initializations"] = "".join(initializations)
+  domain_maps.append(domain_map)
 
+for domain_map in domain_maps:
+  domain = domain_map["Domain"]
+  if domain in redirects:
+    domain_map["initializations"] += "".join(redirects[domain])
+  handler_method_impls.append(tmpl_setter_impl.substitute(domain_map))
 
 output_h_file = open(output_h_path, "w")
 output_cc_file = open(output_cc_path, "w")
 
 output_h_file.write(template_h.substitute({},
     types = "\n".join(type_decls),
     setters = "".join(setters),
     methods = "".join(handler_methods),
     fields = "".join(fields)))
 output_h_file.close()
 
 output_cc_file.write(template_cc.substitute({},
     major = blink_protocol["version"]["major"],
     minor = blink_protocol["version"]["minor"],
     includes = "".join(sorted(includes)),
     fields_init = ",\n      ".join(fields_init),
     methods = "\n".join(handler_method_impls),
     types = "\n".join(type_impls)))
 output_cc_file.close()