[DevTools] Make generated protocol structs wrappers around DictionaryValue

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
 
 input_json_path = sys.argv[1]
@@ skipping 16 matching lines @@
 #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_
 #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_
 
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/browser/devtools/protocol/devtools_protocol_client.h"
 
 namespace content {
 
 class DevToolsProtocolHandlerImpl;
 
+class ListBuilderBase {

[dgozman, 2014/11/06 14:20:42]

Let's put ListBuilder in content::devtools.

[vkuzkokov, 2014/11/06 16:30:12]

Done.

+ public:
+  static scoped_ptr<base::ListValue> ToValue(ListBuilderBase src);
+
+ protected:
+  ListBuilderBase();
+  ListBuilderBase(scoped_ptr<base::ListValue> list_);
+
+  scoped_ptr<base::ListValue> list_;
+};
+
+template<class T>
+class ListBuilder : public ListBuilderBase {
+  MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(ListBuilder)
+ public:
+  ListBuilder() {}
+  ListBuilder(ListBuilder&& other) : ListBuilderBase(other.list_.Pass()) {
+  }
+
+  void push_back(T item) {
+    list_->Append(T::ToValue(item.Pass()).release());
+  }
+};
+
+template<>
+class ListBuilder<std::string> : public ListBuilderBase {
+  MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(ListBuilder)
+ public:
+  ListBuilder() {}
+  ListBuilder(ListBuilder&& other) : ListBuilderBase(other.list_.Pass()) {
+  }
+
+  void push_back(const std::string& item) {
+    list_->AppendString(item);
+  }
+};
+
 namespace devtools {
 
 ${types}\
 
 }  // namespace devtools
 
 class DevToolsProtocolHandlerImpl : public DevToolsProtocol::Handler {
  public:
   typedef DevToolsProtocolClient::Response Response;
   typedef DevToolsProtocolClient::ResponseStatus ResponseStatus;
 
   DevToolsProtocolHandlerImpl();
   virtual ~DevToolsProtocolHandlerImpl();
 
 ${setters}\
 
  private:
-${friends}\
-
 ${methods}\
 
 ${fields}\
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_HANDLER_IMPL_H_
 """)
 
 tmpl_typedef = string.Template("""\
 namespace ${domain} {
 typedef ${param_type} ${declared_name};
 }  // namespace ${domain}
 """)
 
 tmpl_struct = string.Template("""\
 namespace ${domain} {
-struct ${declared_name} {
+template<int MASK>
+struct ${declared_name}Builder {
+  MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(${declared_name}Builder)
  public:
-  ${declared_name}();
+  enum {
+    kAllSet = 0,
+${fields_enum}\
+  };
 
 ${methods}\
 
+  static ${declared_name}Builder<kNoneSet> Create() {
+    return ${declared_name}Builder<kNoneSet>();
+  }
+
+  static scoped_ptr<base::DictionaryValue> ToValue(
+      ${declared_name}Builder src) {
+    return src.dict_.Pass();
+  }
+
+  ${declared_name}Builder(${declared_name}Builder&& other)
+    : dict_(other.dict_.Pass()) {
+  }
+
  private:
-  friend class ::content::DevToolsProtocolHandlerImpl;
+  friend struct ${declared_name}Builder<0>;
 
-${fields}\
+  ${declared_name}Builder() : dict_(new base::DictionaryValue()) {
+  }
+
+  template<class T> T& ThisAs() {
+    COMPILE_ASSERT(sizeof(*this) == sizeof(T), cannot_cast);
+    return *reinterpret_cast<T*>(this);
+  }
+
+  scoped_ptr<base::DictionaryValue> dict_;
 };
+
+typedef ${declared_name}Builder<0> ${declared_name};
+
 }  // namespace ${domain}
 """)
 
-tmpl_struct_setter = string.Template("""\
-  void set_${param}(${pass_type} ${param});
+tmpl_builder_setter_req = string.Template("""\
+  ${declared_name}Builder<MASK & ~k${Param}>&
+  set_${param}(${pass_type} ${param}) {
+    COMPILE_ASSERT(MASK & k${Param}, already_set);
+${builder_wrap}\
+    return ThisAs<${declared_name}Builder<MASK & ~k${Param}>>();
+  }
 """)
 
-tmpl_struct_field = string.Template("""\
-  ${param_type} ${param}_;
-  bool has_${param}_;
+tmpl_builder_setter_opt = string.Template("""\
+  ${declared_name}Builder<MASK>&
+  set_${param}(${pass_type} ${param}) {
+${builder_wrap}\
+    return *this;
+  }
+""")
+
+tmpl_builder_enum = string.Template("""\
+    k${Param} = 1 << ${ordinal},
+""")
+
+tmpl_builder_none_set = string.Template("""\
+    kNoneSet = ${all_fields}
 """)
 
 tmpl_enum = string.Template("""\
 namespace ${domain} {
 namespace ${subdomain} {
 ${values}\
 }  // namespace ${subdomain}
 }  // namespace ${domain}
 """)
 
@@ skipping 18 matching lines @@
   Client(const RawMessageCallback& raw_message_callback);
   virtual ~Client();
 
 ${methods}\
 };
 }  // namespace ${domain}
 """)
 
 tmpl_event = string.Template("""\
   void ${Command}(
-      const ${Command}Params& params);
+      ${Command}Params params);
 """)
 
 tmpl_response = string.Template("""\
   void Send${Command}Response(
       scoped_refptr<DevToolsProtocol::Command> command,
-      const ${Command}Response& params);
+      ${Command}Response params);
 """)
 
 tmpl_setter = string.Template("""\
   void Set${Domain}Handler(
       devtools::${domain}::${Domain}Handler* ${domain}_handler);
 """)
 
-tmpl_friend = string.Template("""\
-  friend class devtools::${domain}::Client;
-""")
-
 tmpl_callback = string.Template("""\
   scoped_refptr<DevToolsProtocol::Response>
   On${Domain}${Command}(
       scoped_refptr<DevToolsProtocol::Command> command);
 """)
 
-tmpl_to_value = string.Template("""\
-  static base::DictionaryValue* ToValue(
-      const devtools::${domain}::${declared_name}& src);
-""")
-
 tmpl_field = string.Template("""\
   devtools::${domain}::${Domain}Handler* ${domain}_handler_;
 """)
 
 template_cc = string.Template(header + """\
 
 #include "content/browser/devtools/protocol/devtools_protocol_handler_impl.h"
 
 #include "base/bind.h"
 ${includes}\
 
 namespace content {
 
+ListBuilderBase::ListBuilderBase()
+    : list_(new base::ListValue) {
+}
+
+ListBuilderBase::ListBuilderBase(scoped_ptr<base::ListValue> list)
+    : list_(list.Pass()) {
+}
+
+// static
+scoped_ptr<base::ListValue> ListBuilderBase::ToValue(
+    ListBuilderBase src) {
+  return src.list_.Pass();
+}
+
 DevToolsProtocolHandlerImpl::DevToolsProtocolHandlerImpl()
     : ${fields_init} {
 }
 
 DevToolsProtocolHandlerImpl::~DevToolsProtocolHandlerImpl() {
 }
 
 namespace {
 
 typedef DevToolsProtocolClient::ResponseStatus ResponseStatus;
 
 bool CreateCommonResponse(
     scoped_refptr<DevToolsProtocol::Command> command,
     const DevToolsProtocolClient::Response& response,
     scoped_refptr<DevToolsProtocol::Response>* protocol_response) {
   switch (response.status()) {
     case ResponseStatus::RESPONSE_STATUS_FALLTHROUGH:
-      *protocol_response = NULL;
+      *protocol_response = nullptr;
       break;
     case ResponseStatus::RESPONSE_STATUS_OK:
       return false;
     case ResponseStatus::RESPONSE_STATUS_INVALID_PARAMS:
       *protocol_response = command->InvalidParamResponse(response.message());
       break;
     case ResponseStatus::RESPONSE_STATUS_INTERNAL_ERROR:
       *protocol_response = command->InternalErrorResponse(response.message());
       break;
     case ResponseStatus::RESPONSE_STATUS_SERVER_ERROR:
@@ skipping 13 matching lines @@
 
 }  // namespace devtools
 
 }  // namespace content
 """)
 
 tmpl_include = string.Template("""\
 #include "content/browser/devtools/protocol/${domain}_handler.h"
 """)
 
-tmpl_field_init = string.Template("${domain}_handler_(NULL)")
+tmpl_field_init = string.Template("${domain}_handler_(nullptr)")
 
 tmpl_setter_impl = string.Template("""\
 void DevToolsProtocolHandlerImpl::Set${Domain}Handler(
     devtools::${domain}::${Domain}Handler* ${domain}_handler) {
   DCHECK(!${domain}_handler_);
   ${domain}_handler_ = ${domain}_handler;
 ${initializations}\
 }
 """)
 
@@ skipping 14 matching lines @@
 
 tmpl_callback_impl = string.Template("""\
 scoped_refptr<DevToolsProtocol::Response>
 DevToolsProtocolHandlerImpl::On${Domain}${Command}(
     scoped_refptr<DevToolsProtocol::Command> command) {
 ${prep}\
   Response response = ${domain}_handler_->${Command}(${args});
   scoped_refptr<DevToolsProtocol::Response> protocol_response;
   if (CreateCommonResponse(command, response, &protocol_response))
     return protocol_response;
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  base::DictionaryValue* result = new base::DictionaryValue();
 ${wrap}\
-  return command->SuccessResponse(dict);
+  return command->SuccessResponse(result);
 }
 """)
 
 tmpl_callback_async_impl = string.Template("""\
 scoped_refptr<DevToolsProtocol::Response>
 DevToolsProtocolHandlerImpl::On${Domain}${Command}(
     scoped_refptr<DevToolsProtocol::Command> command) {
 ${prep}\
   return ${domain}_handler_->${Command}(${args});
 }
 """)
 
 params_prep = """\
   base::DictionaryValue* params = command->params();
 """
 
 tmpl_prep_req = string.Template("""\
   ${param_type} in_${param}${init};
-  if (!params ||
-      !params->Get${Type}("${proto_param}", &in_${param}))
+  if (!params || !params->Get${Type}("${proto_param}", &in_${param}))
     return command->InvalidParamResponse("${proto_param}");
 """)
 
 tmpl_prep_req_list = string.Template("""\
-  base::ListValue* list_${param} = NULL;
+  base::ListValue* list_${param} = nullptr;
   if (!params || !params->GetList("${proto_param}", &list_${param}))
     return command->InvalidParamResponse("${proto_param}");
-  ${param_type} in_${param};
+  std::vector<${item_type}> in_${param};
   for (base::ListValue::const_iterator it =
       list_${param}->begin(); it != list_${param}->end(); ++it) {
     ${item_type} item${item_init};
     if (!(*it)->GetAs${ItemType}(&item))
       return command->InvalidParamResponse("${proto_param}");
     in_${param}.push_back(item);
   }
 """)
 
 tmpl_prep_opt = string.Template("""\
   ${param_type} in_${param}${init};
   bool ${param}_found = params && params->Get${Type}(
       "${proto_param}",
       &in_${param});
 """)
 
 tmpl_prep_output = string.Template("""\
   ${param_type} out_${param}${init};
 """)
 
 tmpl_arg_req = string.Template("in_${param}")
 
 tmpl_arg_opt = string.Template(
-    "${param}_found ?\n          &in_${param} : NULL")
-
-tmpl_arg_output = string.Template("&out_${param}")
-
-tmpl_to_value_impl = string.Template("""\
-// static
-base::DictionaryValue* DevToolsProtocolHandlerImpl::ToValue(
-    const devtools::${domain}::${declared_name}& src) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
-${dchecks}\
-${wrap}\
-  return dict;
-}
-""")
-
-tmpl_dcheck = string.Template("""\
-  DCHECK(${cond_name});
-""")
-
-tmpl_struct_impl = string.Template("""\
-namespace ${domain} {
-
-${declared_name}::${declared_name}()${fields} {
-}
-
-${methods}\
-
-}  // namespace ${domain}
-""")
-
-tmpl_struct_field_init = string.Template("has_${param}_(false)")
-
-tmpl_struct_setter_impl = string.Template("""\
-void ${declared_name}::set_${param}(
-    ${pass_type} ${param}) {
-  ${param}_ = ${param};
-  has_${param}_ = true;
-}
-""")
+    "${param}_found ? &in_${param} : nullptr")
 
 tmpl_client_impl = string.Template("""\
 namespace ${domain} {
 
 Client::Client(const RawMessageCallback& raw_message_callback)
     : DevToolsProtocolClient(raw_message_callback) {
 }
 
 Client::~Client() {
 }
 
 ${methods}\
 
 }  // namespace ${domain}
 """)
 
 tmpl_event_impl = string.Template("""\
 void Client::${Command}(
-    const ${Command}Params& params) {
+    ${Command}Params params) {
   SendNotification("${Domain}.${command}",
-      DevToolsProtocolHandlerImpl::ToValue(params));
+      ${Command}Params::ToValue(params.Pass()).Pass());
 }
 """)
 
 tmpl_response_impl = string.Template("""\
 void Client::Send${Command}Response(
     scoped_refptr<DevToolsProtocol::Command> command,
-    const ${Command}Response& params) {
+    ${Command}Response params) {
   SendAsyncResponse(
-      command->SuccessResponse(DevToolsProtocolHandlerImpl::ToValue(params)));
+      command->SuccessResponse(
+          ${Command}Response::ToValue(params.Pass()).release()));
 }
 """)
 
 tmpl_wrap = string.Template("""\
-  dict->Set${Type}("${proto_param}", ${var_name});
+  ${dict_var}->Set${Type}("${proto_param}", ${var_name});
 """)
 
 tmpl_wrap_dict = string.Template("""\
-  dict->Set("${proto_param}",
-      DevToolsProtocolHandlerImpl::ToValue(${var_name}));
+  ${dict_var}->Set("${proto_param}",
+      ${param_type}::ToValue(${var_name}.Pass()).release());
 """)
 
+tmpl_wrap_list = tmpl_wrap_dict;
+
 tmpl_wrap_obj = string.Template("""\
-  dict->Set("${proto_param}", ${var_name});
-""")
-
-tmpl_wrap_list = string.Template("""\
-  base::ListValue* list_${param} = new base::ListValue();
-  for (${param_type}::const_iterator it =
-      ${var_name}.begin(); it != ${var_name}.end(); ++it) {
-${append}\
-  }
-  dict->Set("${proto_param}", list_${param});
-""")
-
-tmpl_append = string.Template("""\
-    list_${param}->Append${Type}(*it);
-""")
-
-tmpl_append_dict = string.Template("""\
-    list_${param}->Append(DevToolsProtocolHandlerImpl::ToValue(*it));
-""")
-
-tmpl_append_obj = string.Template("""\
-    list_${param}->Append(*it);
-""")
-
-tmpl_wrap_opt = string.Template("""\
-  if (${cond_name})
-    dict->Set${Type}("${proto_param}", ${var_name});
+  ${dict_var}->Set("${proto_param}", ${var_name}.release());
 """)
 
 tmpl_typename = string.Template("devtools::${domain}::${declared_name}")
 
+def Shift(prefix, s):
+  return "\n".join(map(lambda line: prefix + line, s.splitlines())) + "\n"
+
 def Capitalize(s):
   return s[:1].upper() + s[1:]
 
-def Decapitalize(s):
-  return s.lower()
-
 def Uncamelcase(s):
   result = ""
   for i, c in enumerate(s):
     if c.isupper():
       if (i > 0) and ((i < len(s)-1) and s[i+1].islower() or s[i-1].islower()):
         result += "_"
       result += c.lower()
     else:
       result += c
   return result
 
 types = {}
 json_api = json.loads(open(input_json_path, "r").read())
 type_decls = []
 type_impls = []
 handler_methods = []
 handler_method_impls = []
 
 for json_domain in json_api["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 = []
-  fields = []
-  fields_init = []
-  method_impls = []
-  dchecks = []
-  wrap = []
+  fields_enum = []
+  enum_items = []
+  req_fields_num = 0
   for json_prop in json_properties:
     prop_map = mapping.copy()
     prop_map["proto_param"] = json_prop["name"]
     prop_map["param"] = Uncamelcase(json_prop["name"])
-    prop_map["var_name"] = "src.%s_" % prop_map["param"]
-    prop_map["cond_name"] = "src.has_%s_" % prop_map["param"]
+    prop_map["Param"] = Capitalize(json_prop["name"])
+    prop_map["var_name"] = "%s" % prop_map["param"]
+    prop_map["dict_var"] = "dict_";
     ResolveType(json_prop, prop_map)
     prop_map["declared_name"] = mapping["declared_name"]
-    methods.append(tmpl_struct_setter.substitute(prop_map))
-    fields.append(tmpl_struct_field.substitute(prop_map))
-    fields_init.append(tmpl_struct_field_init.substitute(prop_map))
-    method_impls.append(tmpl_struct_setter_impl.substitute(prop_map))
     if json_prop.get("optional"):
-      if param_map["Type"] in ["List", "Dictionary"]:
-        # TODO(vkuzkokov) Implement.
-        raise Exception(
-          "Optional array and object properties are not implemented")
-      wrap.append(tmpl_wrap_opt.substitute(prop_map))
+      methods.append(tmpl_builder_setter_opt.substitute(prop_map))
     else:
-      dchecks.append(tmpl_dcheck.substitute(prop_map));
-      if not "wrap" in prop_map:
-        raise Exception("Arrays of arrays are not implemented")
-      wrap.append(prop_map["wrap"])
+      methods.append(tmpl_builder_setter_req.substitute(prop_map))
+      enum_items.append("k%s" % prop_map["Param"]);
+      fields_enum.append(tmpl_builder_enum.substitute(prop_map,
+        ordinal = req_fields_num))
+      req_fields_num += 1
 
+  all_fields = "kAllSet"
+  if len(enum_items) > 0:
+    all_fields = " | ".join(enum_items)
+  fields_enum.append(tmpl_builder_none_set.substitute(mapping,
+      all_fields = all_fields))
   type_decls.append(tmpl_struct.substitute(mapping,
-      methods = "".join(methods),
-      fields = "".join(fields)))
-  fields_init_str = ""
-  if len(fields_init) > 0:
-    fields_init_str = "\n    : " + (",\n      ".join(fields_init))
-  type_impls.append(tmpl_struct_impl.substitute(mapping,
-      fields = fields_init_str,
-      methods = "\n".join(method_impls)))
-  handler_methods.append(tmpl_to_value.substitute(mapping))
-  handler_method_impls.append(tmpl_to_value_impl.substitute(mapping,
-      dchecks = "".join(dchecks),
-      wrap = "".join(wrap)))
+      methods = "\n".join(methods),
+      fields_enum = "".join(fields_enum)))
 
 def ResolveRef(json, mapping):
   dot_pos = json["$ref"].find(".")
   if dot_pos == -1:
     domain_name = mapping["Domain"]
     type_name = json["$ref"]
   else:
     domain_name = json["$ref"][:dot_pos]
     type_name = json["$ref"][dot_pos + 1:]
   json_type = types["%s.%s" % (domain_name, type_name)]
   mapping["declared_name"] = Capitalize(type_name)
   mapping["Domain"] = domain_name
-  mapping["domain"] = Decapitalize(domain_name)
+  mapping["domain"] = Uncamelcase(domain_name)
   mapping["param_type"] = tmpl_typename.substitute(mapping)
   if json_type.get("enum"):
     # TODO(vkuzkokov) Implement. Approximate template:
     # namespace ${domain} { const char k${declared_name}${Value}; }
     raise Exception("Named enumerations are not implemented")
   ResolveType(json_type, mapping)
   if not "___struct_declared" in json_type:
     json_type["___struct_declared"] = True;
     if (json_type.get("type") == "object") and ("properties" in json_type):
       DeclareStruct(json_type["properties"], mapping)
     else:
       type_decls.append(tmpl_typedef.substitute(mapping))
   mapping["param_type"] = tmpl_typename.substitute(mapping)
 
 def ResolveArray(json, mapping):
   items_map = mapping.copy()
   ResolveType(json["items"], items_map)
-  mapping["param_type"] = "std::vector<%s>" % items_map["param_type"]
+  mapping["param_type"] = "ListBuilder<%s>" % items_map["param_type"]
   mapping["Type"] = "List"
-  if "append" in items_map:
-    mapping["wrap"] = tmpl_wrap_list.substitute(mapping,
-        append = items_map["append"])
-  mapping["pass_type"] = "const %s&" % mapping["param_type"]
+  mapping["wrap"] = tmpl_wrap_list.substitute(mapping)
+  mapping["pass_type"] = mapping["param_type"]
   mapping["prep_req"] = tmpl_prep_req_list.substitute(mapping,
       item_type = items_map["param_type"],
       item_init = items_map["init"],
       ItemType = items_map["Type"])
-  # TODO(vkuzkokov) mapping["append"]: template for array of arrays.
+  mapping["arg_out"] = "&%s" % mapping["var_name"]
 
 def ResolveObject(json, mapping):
   mapping["Type"] = "Dictionary"
   if "properties" in json:
     if not "declared_name" in mapping:
       mapping["declared_name"] = ("%s%s" %
           (mapping["Command"], Capitalize(mapping["proto_param"])))
       mapping["param_type"] = tmpl_typename.substitute(mapping)
       DeclareStruct(json["properties"], mapping)
-    mapping["append"] = tmpl_append_dict.substitute(mapping)
     mapping["wrap"] = tmpl_wrap_dict.substitute(mapping)
-    mapping["pass_type"] = "const %s&" % mapping["param_type"]
+    mapping["pass_type"] = mapping["param_type"]
+    mapping["arg_out"] = "&%s" % mapping["var_name"]
   else:
-    mapping["param_type"] = "base::DictionaryValue*"
-    mapping["append"] = tmpl_append_obj.substitute(mapping)
+    mapping["param_type"] = "base::DictionaryValue"
     mapping["wrap"] = tmpl_wrap_obj.substitute(mapping)
-    mapping["pass_type"] = mapping["param_type"]
+    mapping["pass_type"] = "scoped_ptr<base::DictionaryValue>"
+    mapping["arg_out"] = "%s.get()" % mapping["var_name"]
 
 def ResolvePrimitive(json, mapping):
   jsonrpc_type = json["type"]
   if jsonrpc_type == "boolean":
     mapping["param_type"] = "bool"
     mapping["Type"] = "Boolean"
     mapping["init"] = " = false"
   elif jsonrpc_type == "integer":
     mapping["param_type"] = "int"
     mapping["Type"] = "Integer"
@@ skipping 20 matching lines @@
         value_defs.append(tmpl_enum_value_def.substitute(mapping,
             value = enum_value,
             Value = Capitalize(enum_value)))
       type_decls.append(tmpl_enum.substitute(mapping,
           values = "".join(values)))
       type_impls.append(tmpl_enum.substitute(mapping,
           values = "".join(value_defs)))
   else:
     raise Exception("Unknown type: %s" % json_type)
   mapping["wrap"] = tmpl_wrap.substitute(mapping)
-  mapping["append"] = tmpl_append.substitute(mapping)
   mapping["prep_req"] = tmpl_prep_req.substitute(mapping)
   if jsonrpc_type != "string":
     mapping["pass_type"] = mapping["param_type"]
+  mapping["arg_out"] = "&%s" % mapping["var_name"]
 
 def ResolveType(json, mapping):
   mapping["init"] = ""
   if "$ref" in json:
     ResolveRef(json, mapping)
   elif "type" in json:
     jsonrpc_type = json["type"]
     if jsonrpc_type == "array":
       ResolveArray(json, mapping)
     elif jsonrpc_type == "object":
       ResolveObject(json, mapping)
     else:
       ResolvePrimitive(json, mapping)
   else:
     raise Exception("Unknown type at %s.%s %s" %
         (mapping["Domain"], mapping["command"], mapping["proto_param"]))
+  mapping["builder_wrap"] = Shift("  ", mapping["wrap"])
 
 setters = []
-friends = []
 fields = []
 
 includes = []
 fields_init = []
 
 for json_domain in json_api["domains"]:
   domain_map = {}
   domain_map["Domain"] = json_domain["domain"]
-  domain_map["domain"] = Decapitalize(json_domain["domain"])
+  domain_map["domain"] = Uncamelcase(json_domain["domain"])
 
   initializations = []
   client_methods = []
   client_method_impls = []
   domain_empty = True
   domain_needs_client = False
 
   if "commands" in json_domain:
     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"])
 
       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"])
           param_map["var_name"] = "in_%s" % param_map["param"]
+          param_map["dict_var"] = "result"
 
           ResolveType(json_param, param_map)
           if len(prep) == 0:
             prep.append(params_prep)
           if json_param.get("optional"):
             if param_map["Type"] in ["List", "Dictionary"]:
               # TODO(vkuzkokov) Implement transformation of base::ListValue
               # to std::vector and base::DictonaryValue to struct.
               raise Exception(
                   "Optional array and object parameters are not implemented")
@@ skipping 21 matching lines @@
         client_methods.append(tmpl_response.substitute(command_map))
         client_method_impls.append(tmpl_response_impl.substitute(command_map))
       else:
         wrap = []
         if "returns" in json_command:
           for json_param in json_command["returns"]:
             param_map = command_map.copy()
             param_map["proto_param"] = json_param["name"]
             param_map["param"] = Uncamelcase(json_param["name"])
             param_map["var_name"] = "out_%s" % param_map["param"]
+            param_map["dict_var"] = "result"
 
             if json_param.get("optional"):
               # TODO(vkuzkokov) Implement Optional<T> for value types.
               raise Exception("Optional return values are not implemented")
             ResolveType(json_param, param_map)
             prep.append(tmpl_prep_output.substitute(param_map))
-            args.append(tmpl_arg_output.substitute(param_map))
+            args.append(param_map["arg_out"])
             if not "wrap" in param_map:
               raise Exception("Arrays of arrays are not implemented")
             wrap.append(param_map["wrap"])
 
         args_str = ""
         if len(args) > 0:
           args_str = "\n      " + ",\n      ".join(args)
         handler_method_impls.append(tmpl_callback_impl.substitute(command_map,
             prep = "".join(prep),
             args = args_str,
@@ skipping 26 matching lines @@
   if domain_empty:
     continue
   type_decls.append(tmpl_handler.substitute(domain_map))
   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)))
-    friends.append(tmpl_friend.substitute(domain_map))
     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)))
 
 
 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),
-    friends = "".join(friends),
     methods = "".join(handler_methods),
     fields = "".join(fields)))
 output_h_file.close()
 
 output_cc_file.write(template_cc.substitute({},
     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()