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