[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 {
+ public:
+  static scoped_ptr<base::ListValue> ToValue(scoped_ptr<ListBuilderBase> src);
+
+ protected:
+  scoped_ptr<base::ListValue> list_;
+};
+
+template<class T> class ListBuilder : public ListBuilderBase {

[dgozman, 2014/10/17 10:51:57]

nit: template<...> is usually on the separate line.

[vkuzkokov, 2014/10/17 11:41:25]

Done.

+ public:
+  typedef scoped_ptr<T> item_type;
+
+  void push_back(scoped_ptr<T> item) {
+    list_->Append(T::ToValue(item.Pass()).release());
+  }
+};
+
+template<> class ListBuilder<std::string> : public ListBuilderBase {

[dgozman, 2014/10/17 10:51:57]

ditto

[vkuzkokov, 2014/10/17 11:41:25]

Done.

+ public:
+  typedef const std::string& item_type;
+
+  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} {
  public:
   ${declared_name}();
 
+  static scoped_ptr<base::DictionaryValue> ToValue(
+      scoped_ptr<${declared_name}> src);
+
 ${methods}\
 
  private:
-  friend class ::content::DevToolsProtocolHandlerImpl;
+  scoped_ptr<base::DictionaryValue> dict_;
+${fields}\
 
-${fields}\
+  DISALLOW_COPY_AND_ASSIGN(${declared_name});
 };
 }  // namespace ${domain}
 """)
 
 tmpl_struct_setter = string.Template("""\
   void set_${param}(${pass_type} ${param});
 """)
 
 tmpl_struct_field = string.Template("""\
-  ${param_type} ${param}_;
   bool has_${param}_;
 """)
 
 tmpl_enum = string.Template("""\
 namespace ${domain} {
 namespace ${subdomain} {
 ${values}\
 }  // namespace ${subdomain}
 }  // namespace ${domain}
 """)
@@ skipping 20 matching lines @@
          const ResponseCallback& response_callback);
   virtual ~Client();
 
 ${methods}\
 };
 }  // namespace ${domain}
 """)
 
 tmpl_event = string.Template("""\
   void ${Command}(
-      const ${Command}Params& params);
+      scoped_ptr<${Command}Params> params);
 """)
 
 tmpl_response = string.Template("""\
   void Send${Command}Response(
       scoped_refptr<DevToolsProtocol::Command> command,
-      const ${Command}Response& params);
+      scoped_ptr<${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 {
 
+// static
+scoped_ptr<base::ListValue> ListBuilderBase::ToValue(
+    scoped_ptr<ListBuilderBase> src) {
+  return src ? src->list_.Pass() : nullptr;
+}
+
 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 16 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}))
+  ${storage_type} in_${param}${init};
+  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};
+  ${storage_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};
+  ${storage_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_arg_opt = string.Template("${param}_found ? &in_${param} : nullptr")

[dgozman, 2014/10/17 10:51:57]

nit: keep the line break

[vkuzkokov, 2014/10/17 11:41:25]

Done.

 
 tmpl_dcheck = string.Template("""\
-  DCHECK(${cond_name});
+  DCHECK(src->has_${param}_);
 """)
 
 tmpl_struct_impl = string.Template("""\
 namespace ${domain} {
 
 ${declared_name}::${declared_name}()${fields} {
 }
 
+// static
+scoped_ptr<base::DictionaryValue> ${declared_name}::ToValue(
+    scoped_ptr<${declared_name}> src) {
+  if (!src)
+    return nullptr;
+${dchecks}\
+  return src->dict_.Pass();
+}
+
 ${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};
+${wrap}\
   has_${param}_ = true;

[dgozman, 2014/10/17 10:51:57]

We should remove "has_${param}_" entirely, and use base::DictionaryValue::HasKey
instead.

[vkuzkokov, 2014/10/17 11:41:25]

Done.

 }
 """)
 
 tmpl_client_impl = string.Template("""\
 namespace ${domain} {
 
 Client::Client(const EventCallback& event_callback,
                const ResponseCallback& response_callback)
     : DevToolsProtocolClient(event_callback, response_callback) {
 }
 
 Client::~Client() {
 }
 
 ${methods}\
 
 }  // namespace ${domain}
 """)
 
 tmpl_event_impl = string.Template("""\
 void Client::${Command}(
-    const ${Command}Params& params) {
+    scoped_ptr<${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) {
+    scoped_ptr<${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});
 """)
 
 tmpl_typename = string.Template("devtools::${domain}::${declared_name}")
 
 def Capitalize(s):
   return s[:1].upper() + s[1:]
 
 def Decapitalize(s):
   return s.lower()
 
@@ skipping 19 matching lines @@
   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 = []
   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["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))
-    else:
+    if not json_prop.get("optional"):
       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"])
 
   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(method_impls),
+      dchecks = "".join(dchecks)))
 
 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)]
@@ skipping 10 matching lines @@
     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"] = "scoped_ptr<%s>" % mapping["param_type"]
+  mapping["storage_type"] = mapping["pass_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.get()" % 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"]
   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<%s>" % mapping["param_type"]
+  mapping["storage_type"] = mapping["pass_type"]
+  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["storage_type"] = mapping["param_type"]
   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"]))
 
 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"])
 
@@ skipping 16 matching lines @@
 
       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()