content/browser/devtools/protocol/devtools_protocol_handler_generator.py

   1 #!/usr/bin/env python
   2 # Copyright 2014 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 import sys
   7 import string
   8 import json
   9
  10 blink_protocol_path = sys.argv[1]
  11 browser_protocol_path = sys.argv[2]
  12 output_cc_path = sys.argv[3]
  13 output_h_path = sys.argv[4]
  14
  15 header = """\
  16 // Copyright 2014 The Chromium Authors. All rights reserved.
  17 // Use of this source code is governed by a BSD-style license that can be
  18 // found in the LICENSE file.
  19
  20 // THIS FILE IS AUTOGENERATED. DO NOT EDIT.
  21 // Generated by
  22 //  content/public/browser/devtools_protocol_handler_generator.py from
  23 //  third_party/WebKit/Source/devtools/protocol.json and
  24 //  content/browser/devtools/browser_protocol.json
  25 """
  26
  27 template_h = string.Template(header + """\
  28
  29 #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
  30 #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
  31
  32 #include "content/browser/devtools/protocol/devtools_protocol_client.h"
  33
  34 namespace content {
  35
  36 class DevToolsProtocolDispatcher;
  37
  38 namespace devtools {
  39
  40 extern const char kProtocolVersion[];
  41
  42 bool IsSupportedProtocolVersion(const std::string& version);
  43
  44 template<typename T>
  45 base::Value* CreateValue(const T& param) {
  46   return new base::FundamentalValue(param);
  47 }
  48
  49 template<class T>
  50 base::Value* CreateValue(scoped_ptr<T>& param) {
  51   return param.release();
  52 }
  53
  54 template<class T>
  55 base::Value* CreateValue(scoped_refptr<T> param) {
  56   return param->ToValue().release();
  57 }
  58
  59 template<typename T>
  60 base::Value* CreateValue(const std::vector<T> param) {
  61   base::ListValue* result = new base::ListValue();
  62   for (auto& item : param) {
  63     result->Append(CreateValue(item));
  64   }
  65   return result;
  66 }
  67
  68 template<>
  69 base::Value* CreateValue(const std::string& param);
  70
  71 ${types}\
  72
  73 }  // namespace devtools
  74
  75 class DevToolsProtocolDispatcher {
  76  public:
  77   using Notifier = DevToolsProtocolClient::RawMessageCallback;
  78   using CommandHandler =
  79       base::Callback<bool(int, scoped_ptr<base::DictionaryValue>)>;
  80
  81   explicit DevToolsProtocolDispatcher(const Notifier& notifier);
  82   ~DevToolsProtocolDispatcher();
  83
  84   CommandHandler FindCommandHandler(const std::string& method);
  85
  86 ${setters}\
  87
  88  private:
  89   using Response = DevToolsProtocolClient::Response;
  90   using CommandHandlers = std::map<std::string, CommandHandler>;
  91
  92 ${methods}\
  93
  94   Notifier notifier_;
  95   DevToolsProtocolClient client_;
  96   CommandHandlers command_handlers_;
  97 ${fields}\
  98 };
  99
 100 }  // namespace content
 101
 102 #endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
 103 """)
 104
 105 tmpl_typedef = string.Template("""\
 106 namespace ${domain} {
 107 typedef ${param_type} ${declared_name};
 108 }  // namespace ${domain}
 109 """)
 110
 111 tmpl_struct = string.Template("""\
 112 namespace ${domain} {
 113 template<int MASK>
 114 struct ${declared_name}Builder
 115     : base::RefCounted<${declared_name}Builder<MASK>> {
 116  public:
 117   enum {
 118     kAllSet = 0,
 119 ${fields_enum}\
 120   };
 121
 122 ${methods}\
 123
 124   static scoped_refptr<${declared_name}Builder<kNoneSet>> Create() {
 125     return new ${declared_name}Builder<kNoneSet>();
 126   }
 127
 128   scoped_ptr<base::DictionaryValue> ToValue() {
 129     static_assert(MASK == kAllSet, "required properties missing");
 130     return make_scoped_ptr(dict_->DeepCopy());
 131   }
 132
 133  private:
 134   friend struct ${declared_name}Builder<0>;
 135
 136   ${declared_name}Builder() : dict_(new base::DictionaryValue()) {
 137   }
 138
 139   template<class T> T* ThisAs() {
 140     static_assert(sizeof(*this) == sizeof(T), "cannot cast");
 141     return reinterpret_cast<T*>(this);
 142   }
 143
 144   scoped_ptr<base::DictionaryValue> dict_;
 145 };
 146
 147 typedef ${declared_name}Builder<0> ${declared_name};
 148
 149 }  // namespace ${domain}
 150 """)
 151
 152 tmpl_builder_setter_req = string.Template("""\
 153   scoped_refptr<${declared_name}Builder<MASK & ~k${Param}>>
 154   set_${param}(${pass_type} ${param}) {
 155     static_assert(MASK & k${Param}, "already set");
 156     dict_->Set("${proto_param}", CreateValue(${param}));
 157     return ThisAs<${declared_name}Builder<MASK & ~k${Param}>>();
 158   }
 159 """)
 160
 161 tmpl_builder_setter_opt = string.Template("""\
 162   scoped_refptr<${declared_name}Builder<MASK>>
 163   set_${param}(${pass_type} ${param}) {
 164     dict_->Set("${proto_param}", CreateValue(${param}));
 165     return this;
 166   }
 167 """)
 168
 169 tmpl_builder_enum = string.Template("""\
 170     k${Param} = 1 << ${ordinal},
 171 """)
 172
 173 tmpl_builder_none_set = string.Template("""\
 174     kNoneSet = ${all_fields}
 175 """)
 176
 177 tmpl_named_enum = string.Template("""\
 178 namespace ${domain} {
 179 ${values}\
 180 }  // namespace ${domain}
 181 """)
 182
 183 tmpl_inline_enum = string.Template("""\
 184 namespace ${domain} {
 185 namespace ${subdomain} {
 186 ${values}\
 187 }  // namespace ${subdomain}
 188 }  // namespace ${domain}
 189 """)
 190
 191 tmpl_enum_value = string.Template("""\
 192 extern const char k${Enum}${Value}[];
 193 """)
 194
 195 tmpl_enum_value_def = string.Template("""\
 196 const char k${Enum}${Value}[] = "${value}";
 197 """)
 198
 199 tmpl_handler = string.Template("""\
 200 namespace ${domain} {
 201 class ${Domain}Handler;
 202 }  // namespace domain
 203 """)
 204
 205 tmpl_client = string.Template("""\
 206 namespace ${domain} {
 207 class Client : public DevToolsProtocolClient {
 208  public:
 209   explicit Client(const RawMessageCallback& raw_message_callback);
 210   ~Client() override;
 211
 212 ${methods}\
 213 };
 214 }  // namespace ${domain}
 215 """)
 216
 217 tmpl_event = string.Template("""\
 218   void ${Command}(
 219       scoped_refptr<${Command}Params> params);
 220 """)
 221
 222 tmpl_response = string.Template("""\
 223   void Send${Command}Response(
 224       DevToolsCommandId command_id,
 225       scoped_refptr<${Command}Response> params);
 226 """)
 227
 228 tmpl_setter = string.Template("""\
 229   void Set${Domain}Handler(
 230       devtools::${domain}::${Domain}Handler* ${domain}_handler);
 231 """)
 232
 233 tmpl_callback = string.Template("""\
 234   bool On${Domain}${Command}(
 235       DevToolsCommandId command_id,
 236       scoped_ptr<base::DictionaryValue> params);
 237 """)
 238
 239 tmpl_field = string.Template("""\
 240   devtools::${domain}::${Domain}Handler* ${domain}_handler_;
 241 """)
 242
 243 template_cc = string.Template(header + """\
 244
 245 #include "base/bind.h"
 246 #include "base/strings/string_number_conversions.h"
 247 #include "base/strings/string_split.h"
 248 ${includes}\
 249
 250 namespace content {
 251
 252 DevToolsProtocolDispatcher::DevToolsProtocolDispatcher(
 253     const Notifier& notifier)
 254     : notifier_(notifier),
 255       client_(notifier),
 256       ${fields_init} {
 257 }
 258
 259 DevToolsProtocolDispatcher::~DevToolsProtocolDispatcher() {
 260 }
 261
 262 DevToolsProtocolDispatcher::CommandHandler
 263 DevToolsProtocolDispatcher::FindCommandHandler(const std::string& method) {
 264   CommandHandlers::iterator it = command_handlers_.find(method);
 265   return it == command_handlers_.end() ? CommandHandler() : it->second;
 266 }
 267
 268 ${methods}\
 269
 270 namespace devtools {
 271
 272 const char kProtocolVersion[] = "${major}.${minor}";
 273
 274 bool IsSupportedProtocolVersion(const std::string& version) {
 275   std::vector<base::StringPiece> tokens = base::SplitStringPiece(
 276       version, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
 277   int major, minor;
 278   return tokens.size() == 2 &&
 279       base::StringToInt(tokens[0], &major) && major == ${major} &&
 280       base::StringToInt(tokens[1], &minor) && minor <= ${minor};
 281 }
 282
 283 template<>
 284 base::Value* CreateValue(const std::string& param) {
 285   return new base::StringValue(param);
 286 }
 287
 288 ${types}\
 289
 290 }  // namespace devtools
 291
 292 }  // namespace content
 293 """)
 294
 295 tmpl_include = string.Template("""\
 296 #include "content/browser/devtools/protocol/${domain}_handler.h"
 297 """)
 298
 299 tmpl_field_init = string.Template("${domain}_handler_(nullptr)")
 300
 301 tmpl_setter_impl = string.Template("""\
 302 void DevToolsProtocolDispatcher::Set${Domain}Handler(
 303     devtools::${domain}::${Domain}Handler* ${domain}_handler) {
 304   DCHECK(!${domain}_handler_);
 305   ${domain}_handler_ = ${domain}_handler;
 306 ${initializations}\
 307 }
 308 """)
 309
 310 tmpl_register = string.Template("""\
 311   command_handlers_["${Domain}.${command}"] =
 312       base::Bind(
 313           &DevToolsProtocolDispatcher::On${TargetDomain}${Command},
 314           base::Unretained(this));
 315 """)
 316
 317 tmpl_init_client = string.Template("""\
 318   ${domain}_handler_->SetClient(make_scoped_ptr(
 319       new devtools::${domain}::Client(notifier_)));
 320 """)
 321
 322 tmpl_callback_impl = string.Template("""\
 323 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
 324     DevToolsCommandId command_id,
 325     scoped_ptr<base::DictionaryValue> params) {
 326 ${prep}\
 327   Response response = ${domain}_handler_->${Command}(${args});
 328   scoped_ptr<base::DictionaryValue> protocol_response;
 329   if (client_.SendError(command_id, response))
 330     return true;
 331   if (response.IsFallThrough())
 332     return false;
 333   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 334 ${wrap}\
 335   client_.SendSuccess(command_id, result.Pass());
 336   return true;
 337 }
 338 """)
 339
 340 tmpl_wrap = string.Template("""\
 341   result->Set("${proto_param}", devtools::CreateValue(out_${param}));
 342 """)
 343
 344 tmpl_callback_async_impl = string.Template("""\
 345 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
 346     DevToolsCommandId command_id,
 347     scoped_ptr<base::DictionaryValue> params) {
 348 ${prep}\
 349   Response response = ${domain}_handler_->${Command}(${args});
 350   if (client_.SendError(command_id, response))
 351     return true;
 352   return !response.IsFallThrough();
 353 }
 354 """)
 355
 356 tmpl_prep_req = string.Template("""\
 357   ${raw_type} in_${param}${init};
 358   if (!params || !params->Get${Type}("${proto_param}", &in_${param})) {
 359     client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
 360     return true;
 361   }
 362 """)
 363
 364 tmpl_prep_req_list = string.Template("""\
 365   base::ListValue* list_${param} = nullptr;
 366   if (!params || !params->GetList("${proto_param}", &list_${param})) {
 367     client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
 368     return true;
 369   }
 370   std::vector<${item_type}> in_${param};
 371   for (base::ListValue::const_iterator it =
 372       list_${param}->begin(); it != list_${param}->end(); ++it) {
 373     ${item_raw_type} item;
 374     if (!(*it)->GetAs${ItemType}(&item)) {
 375       client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
 376       return true;
 377     }
 378     in_${param}.push_back(${item_pass});
 379   }
 380 """)
 381
 382 tmpl_prep_opt = string.Template("""\
 383   ${raw_type} in_${param}${init};
 384   bool ${param}_found = params && params->Get${Type}(
 385       "${proto_param}",
 386       &in_${param});
 387 """)
 388
 389 tmpl_prep_output = string.Template("""\
 390   ${param_type} out_${param}${init};
 391 """)
 392
 393 tmpl_arg_name = string.Template("in_${param}")
 394
 395 tmpl_arg_req = string.Template("${param_pass}")
 396
 397 tmpl_arg_opt = string.Template(
 398     "${param}_found ? ${param_pass} : nullptr")
 399
 400 tmpl_object_pass = string.Template(
 401     "make_scoped_ptr<base::DictionaryValue>(${name}->DeepCopy())")
 402
 403 tmpl_client_impl = string.Template("""\
 404 namespace ${domain} {
 405
 406 Client::Client(const RawMessageCallback& raw_message_callback)
 407     : DevToolsProtocolClient(raw_message_callback) {
 408 }
 409
 410 Client::~Client() {
 411 }
 412
 413 ${methods}\
 414
 415 }  // namespace ${domain}
 416 """)
 417
 418 tmpl_event_impl = string.Template("""\
 419 void Client::${Command}(
 420     scoped_refptr<${Command}Params> params) {
 421   SendNotification("${Domain}.${command}",
 422                    params->ToValue().Pass());
 423 }
 424 """)
 425
 426 tmpl_response_impl = string.Template("""\
 427 void Client::Send${Command}Response(
 428     DevToolsCommandId command_id,
 429     scoped_refptr<${Command}Response> params) {
 430   SendSuccess(command_id, params->ToValue().Pass());
 431 }
 432 """)
 433
 434 tmpl_typename = string.Template("devtools::${domain}::${declared_name}")
 435
 436 def Capitalize(s):
 437   return s[:1].upper() + s[1:]
 438
 439 def Uncamelcase(s):
 440   result = ""
 441   for i, c in enumerate(s):
 442     if c.isupper():
 443       if (i > 0) and ((i < len(s)-1) and s[i+1].islower() or s[i-1].islower()):
 444         result += "_"
 445       result += c.lower()
 446     else:
 447       result += c
 448   return result
 449
 450 types = {}
 451 blink_protocol = json.loads(open(blink_protocol_path, "r").read())
 452 browser_protocol = json.loads(open(browser_protocol_path, "r").read())
 453 type_decls = []
 454 type_impls = []
 455 handler_methods = []
 456 handler_method_impls = []
 457 domain_maps = []
 458 redirects = {}
 459
 460 all_domains = blink_protocol["domains"] + browser_protocol["domains"]
 461
 462 for json_domain in all_domains:
 463   if "types" in json_domain:
 464     for json_type in json_domain["types"]:
 465       types["%s.%s" % (json_domain["domain"], json_type["id"])] = json_type
 466
 467 def DeclareStruct(json_properties, mapping):
 468   methods = []
 469   fields_enum = []
 470   enum_items = []
 471   req_fields_num = 0
 472   for json_prop in json_properties:
 473     prop_map = mapping.copy()
 474     prop_map["proto_param"] = json_prop["name"]
 475     prop_map["param"] = Uncamelcase(json_prop["name"])
 476     prop_map["Param"] = Capitalize(json_prop["name"])
 477     prop_map["subdomain"] = Uncamelcase(prop_map["declared_name"])
 478     del prop_map["declared_name"]
 479     ResolveType(json_prop, prop_map)
 480     prop_map["declared_name"] = mapping["declared_name"]
 481     if json_prop.get("optional"):
 482       methods.append(tmpl_builder_setter_opt.substitute(prop_map))
 483     else:
 484       methods.append(tmpl_builder_setter_req.substitute(prop_map))
 485       enum_items.append("k%s" % prop_map["Param"]);
 486       fields_enum.append(tmpl_builder_enum.substitute(prop_map,
 487         ordinal = req_fields_num))
 488       req_fields_num += 1
 489
 490   all_fields = "kAllSet"
 491   if len(enum_items) > 0:
 492     all_fields = " | ".join(enum_items)
 493   fields_enum.append(tmpl_builder_none_set.substitute(mapping,
 494       all_fields = all_fields))
 495   type_decls.append(tmpl_struct.substitute(mapping,
 496       methods = "\n".join(methods),
 497       fields_enum = "".join(fields_enum)))
 498
 499 def DeclareEnum(json, mapping):
 500   values = []
 501   value_defs = []
 502   tmpl_enum = tmpl_inline_enum
 503   if "declared_name" in mapping:
 504     mapping["Enum"] = mapping["declared_name"]
 505     tmpl_enum = tmpl_named_enum
 506   else:
 507     mapping["Enum"] = Capitalize(mapping["proto_param"])
 508
 509   for enum_value in json["enum"]:
 510     values.append(tmpl_enum_value.substitute(mapping,
 511         Value = Capitalize(enum_value)))
 512     value_defs.append(tmpl_enum_value_def.substitute(mapping,
 513         value = enum_value,
 514         Value = Capitalize(enum_value)))
 515   type_decls.append(tmpl_enum.substitute(mapping,
 516       values = "".join(values)))
 517   type_impls.append(tmpl_enum.substitute(mapping,
 518       values = "".join(value_defs)))
 519
 520 def ResolveRef(json, mapping):
 521   dot_pos = json["$ref"].find(".")
 522   if dot_pos == -1:
 523     domain_name = mapping["Domain"]
 524     type_name = json["$ref"]
 525   else:
 526     domain_name = json["$ref"][:dot_pos]
 527     type_name = json["$ref"][dot_pos + 1:]
 528   json_type = types["%s.%s" % (domain_name, type_name)]
 529   mapping["declared_name"] = Capitalize(type_name)
 530   mapping["Domain"] = domain_name
 531   mapping["domain"] = Uncamelcase(domain_name)
 532   mapping["param_type"] = tmpl_typename.substitute(mapping)
 533   ResolveType(json_type, mapping)
 534   if not "___type_declared" in json_type:
 535     json_type["___type_declared"] = True;
 536     if (json_type.get("type") == "object") and ("properties" in json_type):
 537       DeclareStruct(json_type["properties"], mapping)
 538     else:
 539       if ("enum" in json_type):
 540         DeclareEnum(json_type, mapping)
 541       type_decls.append(tmpl_typedef.substitute(mapping))
 542
 543 def ResolveArray(json, mapping):
 544   items_map = mapping.copy()
 545   ResolveType(json["items"], items_map)
 546   if items_map["Type"] == "List":
 547     # TODO(dgozman) Implement this.
 548     raise Exception("Nested arrays are not implemented")
 549   mapping["param_type"] = "std::vector<%s>" % items_map["param_type"]
 550   mapping["Type"] = "List"
 551   mapping["pass_type"] = "const %s&" % mapping["param_type"]
 552   mapping["storage_type"] = "std::vector<%s>" % items_map["storage_type"]
 553   mapping["raw_type"] = mapping["storage_type"]
 554   mapping["prep_req"] = tmpl_prep_req_list.substitute(mapping,
 555       item_type = items_map["storage_type"],
 556       item_init = items_map["init"],
 557       item_raw_type = items_map["raw_type"],
 558       item_pass = items_map["pass_template"].substitute(name="item", opt=""),
 559       ItemType = items_map["Type"])
 560   mapping["arg_out"] = "&out_%s" % mapping["param"]
 561
 562 def ResolveObject(json, mapping):
 563   mapping["Type"] = "Dictionary"
 564   mapping["storage_type"] = "scoped_ptr<base::DictionaryValue>"
 565   mapping["raw_type"] = "base::DictionaryValue*"
 566   mapping["pass_template"] = tmpl_object_pass
 567   if "properties" in json:
 568     if not "declared_name" in mapping:
 569       mapping["declared_name"] = ("%s%s" %
 570           (mapping["Command"], Capitalize(mapping["proto_param"])))
 571       mapping["param_type"] = ("scoped_refptr<%s>" %
 572           tmpl_typename.substitute(mapping))
 573       DeclareStruct(json["properties"], mapping)
 574     else:
 575       mapping["param_type"] = ("scoped_refptr<%s>" %
 576           tmpl_typename.substitute(mapping))
 577     mapping["pass_type"] = mapping["param_type"]
 578     mapping["arg_out"] = "&out_%s" % mapping["param"]
 579   else:
 580     mapping["param_type"] = "base::DictionaryValue"
 581     mapping["pass_type"] = "scoped_ptr<base::DictionaryValue>"
 582     mapping["arg_out"] = "out_%s.get()" % mapping["param"]
 583   mapping["prep_req"] = tmpl_prep_req.substitute(mapping)
 584
 585 def ResolvePrimitive(json, mapping):
 586   jsonrpc_type = json["type"]
 587   if jsonrpc_type == "boolean":
 588     mapping["param_type"] = "bool"
 589     mapping["Type"] = "Boolean"
 590     mapping["init"] = " = false"
 591   elif jsonrpc_type == "integer":
 592     mapping["param_type"] = "int"
 593     mapping["Type"] = "Integer"
 594     mapping["init"] = " = 0"
 595   elif jsonrpc_type == "number":
 596     mapping["param_type"] = "double"
 597     mapping["Type"] = "Double"
 598     mapping["init"] = " = 0.0"
 599   elif jsonrpc_type == "string":
 600     mapping["param_type"] = "std::string"
 601     mapping["pass_type"] = "const std::string&"
 602     mapping["Type"] = "String"
 603     if "enum" in json and not "declared_name" in mapping:
 604       if not "subdomain" in mapping:
 605         mapping["subdomain"] = Uncamelcase(mapping["command"])
 606       DeclareEnum(json, mapping)
 607   else:
 608     raise Exception("Unknown type: %s" % json_type)
 609   mapping["storage_type"] = mapping["param_type"]
 610   mapping["raw_type"] = mapping["param_type"]
 611   mapping["prep_req"] = tmpl_prep_req.substitute(mapping)
 612   if jsonrpc_type != "string":
 613     mapping["pass_type"] = mapping["param_type"]
 614   mapping["arg_out"] = "&out_%s" % mapping["param"]
 615
 616 def ResolveType(json, mapping):
 617   mapping["init"] = ""
 618   mapping["pass_template"] = string.Template("${opt}${name}")
 619   if "$ref" in json:
 620     ResolveRef(json, mapping)
 621   elif "type" in json:
 622     jsonrpc_type = json["type"]
 623     if jsonrpc_type == "array":
 624       ResolveArray(json, mapping)
 625     elif jsonrpc_type == "object":
 626       ResolveObject(json, mapping)
 627     else:
 628       ResolvePrimitive(json, mapping)
 629   else:
 630     raise Exception("Unknown type at %s.%s %s" %
 631         (mapping["Domain"], mapping["command"], mapping["proto_param"]))
 632
 633 setters = []
 634 fields = []
 635
 636 includes = []
 637 fields_init = []
 638
 639 for json_domain in all_domains:
 640   domain_map = {}
 641   domain_map["Domain"] = json_domain["domain"]
 642   domain_map["domain"] = Uncamelcase(json_domain["domain"])
 643
 644   initializations = []
 645   client_methods = []
 646   client_method_impls = []
 647   domain_empty = True
 648   domain_needs_client = False
 649
 650   if "commands" in json_domain:
 651     for json_command in json_domain["commands"]:
 652       if (not ("handlers" in json_command) or
 653           not ("browser" in json_command["handlers"])):
 654         continue
 655       domain_empty = False
 656
 657       command_map = domain_map.copy()
 658       command_map["command"] = json_command["name"]
 659       command_map["Command"] = Capitalize(json_command["name"])
 660
 661       if "redirect" in json_command:
 662         redirect_domain = json_command["redirect"]
 663         if not (redirect_domain in redirects):
 664           redirects[redirect_domain] = []
 665         command_map["TargetDomain"] = redirect_domain
 666         redirects[redirect_domain].append(tmpl_register.substitute(command_map))
 667         continue
 668
 669       command_map["TargetDomain"] = command_map["Domain"]
 670       prep = []
 671       args = []
 672
 673       if "parameters" in json_command:
 674         for json_param in json_command["parameters"]:
 675           param_map = command_map.copy()
 676           param_map["proto_param"] = json_param["name"]
 677           param_map["param"] = Uncamelcase(json_param["name"])
 678           ResolveType(json_param, param_map)
 679           if json_param.get("optional"):
 680             if param_map["Type"] in ["List"]:
 681               # TODO(vkuzkokov) Implement transformation of base::ListValue
 682               # to std::vector and base::DictonaryValue to struct.
 683               raise Exception(
 684                   "Optional array parameters are not implemented")
 685             prep.append(tmpl_prep_opt.substitute(param_map))
 686             param_pass = param_map["pass_template"].substitute(
 687                 name=tmpl_arg_name.substitute(param_map),
 688                 opt="&")
 689             args.append(
 690                 tmpl_arg_opt.substitute(param_map, param_pass=param_pass))
 691           else:
 692             prep.append(param_map["prep_req"])
 693             param_pass = param_map["pass_template"].substitute(
 694                 name=tmpl_arg_name.substitute(param_map),
 695                 opt="")
 696             args.append(
 697                 tmpl_arg_req.substitute(param_map, param_pass=param_pass))
 698
 699       if json_command.get("async"):
 700         domain_needs_client = True
 701         json_returns = []
 702         if "returns" in json_command:
 703           json_returns = json_command["returns"]
 704         command_map["declared_name"] = "%sResponse" % command_map["Command"]
 705         DeclareStruct(json_returns, command_map)
 706         # TODO(vkuzkokov) Pass async callback instance similar to how
 707         # InspectorBackendDispatcher does it. This, however, can work
 708         # only if Blink and Chrome are in the same repo.
 709         args.insert(0, "command_id")
 710         handler_method_impls.append(
 711             tmpl_callback_async_impl.substitute(command_map,
 712                 prep = "".join(prep),
 713                 args = "\n      " + ",\n      ".join(args)))
 714         client_methods.append(tmpl_response.substitute(command_map))
 715         client_method_impls.append(tmpl_response_impl.substitute(command_map))
 716       else:
 717         wrap = []
 718         if "returns" in json_command:
 719           for json_param in json_command["returns"]:
 720             param_map = command_map.copy()
 721             param_map["proto_param"] = json_param["name"]
 722             param_map["param"] = Uncamelcase(json_param["name"])
 723             if json_param.get("optional"):
 724               # TODO(vkuzkokov) Implement Optional<T> for value types.
 725               raise Exception("Optional return values are not implemented")
 726             ResolveType(json_param, param_map)
 727             prep.append(tmpl_prep_output.substitute(param_map))
 728             args.append(param_map["arg_out"])
 729             wrap.append(tmpl_wrap.substitute(param_map))
 730         args_str = ""
 731         if len(args) > 0:
 732           args_str = "\n      " + ",\n      ".join(args)
 733         handler_method_impls.append(tmpl_callback_impl.substitute(command_map,
 734             prep = "".join(prep),
 735             args = args_str,
 736             wrap = "".join(wrap)))
 737
 738       initializations.append(tmpl_register.substitute(command_map))
 739       handler_methods.append(tmpl_callback.substitute(command_map))
 740
 741   if "events" in json_domain:
 742     for json_event in json_domain["events"]:
 743       if (not ("handlers" in json_event) or
 744           not ("browser" in json_event["handlers"])):
 745         continue
 746       domain_empty = False
 747       domain_needs_client = True
 748
 749       event_map = domain_map.copy()
 750       event_map["command"] = json_event["name"]
 751       event_map["Command"] = Capitalize(json_event["name"])
 752
 753       json_parameters = []
 754       if "parameters" in json_event:
 755         json_parameters = json_event["parameters"]
 756       event_map["declared_name"] = "%sParams" % event_map["Command"]
 757       DeclareStruct(json_parameters, event_map);
 758
 759       client_methods.append(tmpl_event.substitute(event_map))
 760       client_method_impls.append(tmpl_event_impl.substitute(event_map))
 761
 762   if domain_empty:
 763     continue
 764   type_decls.append(tmpl_handler.substitute(domain_map))
 765   setters.append(tmpl_setter.substitute(domain_map))
 766   fields.append(tmpl_field.substitute(domain_map))
 767   includes.append(tmpl_include.substitute(domain_map))
 768   fields_init.append(tmpl_field_init.substitute(domain_map))
 769   if domain_needs_client:
 770     type_decls.append(tmpl_client.substitute(domain_map,
 771         methods = "".join(client_methods)))
 772     initializations.append(tmpl_init_client.substitute(domain_map))
 773     type_impls.append(tmpl_client_impl.substitute(domain_map,
 774         methods = "\n".join(client_method_impls)))
 775   domain_map["initializations"] = "".join(initializations)
 776   domain_maps.append(domain_map)
 777
 778 for domain_map in domain_maps:
 779   domain = domain_map["Domain"]
 780   if domain in redirects:
 781     domain_map["initializations"] += "".join(redirects[domain])
 782   handler_method_impls.append(tmpl_setter_impl.substitute(domain_map))
 783
 784 output_h_file = open(output_h_path, "w")
 785 output_cc_file = open(output_cc_path, "w")
 786
 787 output_h_file.write(template_h.substitute({},
 788     types = "\n".join(type_decls),
 789     setters = "".join(setters),
 790     methods = "".join(handler_methods),
 791     fields = "".join(fields)))
 792 output_h_file.close()
 793
 794 output_cc_file.write(template_cc.substitute({},
 795     major = blink_protocol["version"]["major"],
 796     minor = blink_protocol["version"]["minor"],
 797     includes = "".join(sorted(includes)),
 798     fields_init = ",\n      ".join(fields_init),
 799     methods = "\n".join(handler_method_impls),
 800     types = "\n".join(type_impls)))
 801 output_cc_file.close()