Roll IDL to multivm@1316

core/inspector/CodeGeneratorInspector.py

 #!/usr/bin/env python
 # Copyright (c) 2011 Google Inc. All rights reserved.
 # Copyright (c) 2012 Intel Corporation. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 208 matching lines @@
     class BaseType(object):
         need_internal_runtime_cast_ = False
 
         @classmethod
         def request_raw_internal_runtime_cast(cls):
             if not cls.need_internal_runtime_cast_:
                 cls.need_internal_runtime_cast_ = True
 
         @classmethod
         def get_raw_validator_call_text(cls):
-            return "RuntimeCastHelper::assertType<InspectorValue::Type%s>" % cls.get_validate_method_params().template_type
+            return "RuntimeCastHelper::assertType<JSONValue::Type%s>" % cls.get_validate_method_params().template_type
+
+        @staticmethod
+        def get_validate_method_params():
+            raise Exception("Abstract method")
 
     class String(BaseType):
         @staticmethod
         def get_getter_name():
             return "String"
 
         get_setter_name = get_getter_name
 
         @staticmethod
+        def get_constructor_pattern():
+            return "InspectorString::create(%s)"
+
+        @staticmethod
         def get_c_initializer():
             return "\"\""
 
         @staticmethod
         def get_validate_method_params():
             class ValidateMethodParams:
                 template_type = "String"
             return ValidateMethodParams
 
         @staticmethod
@@ skipping 15 matching lines @@
     class Int(BaseType):
         @staticmethod
         def get_getter_name():
             return "Int"
 
         @staticmethod
         def get_setter_name():
             return "Number"
 
         @staticmethod
+        def get_constructor_pattern():
+            return "InspectorBasicValue::create(%s)"
+
+        @staticmethod
         def get_c_initializer():
             return "0"
 
         @classmethod
         def get_raw_validator_call_text(cls):
             return "RuntimeCastHelper::assertInt"
 
         @staticmethod
         def get_output_pass_model():
             return RawTypes.OutputPassModel.ByPointer
@@ skipping 13 matching lines @@
     class Number(BaseType):
         @staticmethod
         def get_getter_name():
             return "Double"
 
         @staticmethod
         def get_setter_name():
             return "Number"
 
         @staticmethod
+        def get_constructor_pattern():
+            return "InspectorBasicValue::create(%s)"
+
+        @staticmethod
         def get_c_initializer():
             return "0"
 
         @staticmethod
         def get_validate_method_params():
             class ValidateMethodParams:
                 template_type = "Number"
             return ValidateMethodParams
 
         @staticmethod
@@ skipping 13 matching lines @@
             return TypeModel.Number
 
     class Bool(BaseType):
         @staticmethod
         def get_getter_name():
             return "Boolean"
 
         get_setter_name = get_getter_name
 
         @staticmethod
+        def get_constructor_pattern():
+            return "InspectorBasicValue::create(%s)"
+
+        @staticmethod
         def get_c_initializer():
             return "false"
 
         @staticmethod
         def get_validate_method_params():
             class ValidateMethodParams:
                 template_type = "Boolean"
             return ValidateMethodParams
 
         @staticmethod
@@ skipping 15 matching lines @@
     class Object(BaseType):
         @staticmethod
         def get_getter_name():
             return "Object"
 
         @staticmethod
         def get_setter_name():
             return "Value"
 
         @staticmethod
+        def get_constructor_pattern():
+            return "%s"
+
+        @staticmethod
         def get_c_initializer():
-            return "InspectorObject::create()"
+            return "JSONObject::create()"
 
         @staticmethod
         def get_output_argument_prefix():
             return ""
 
         @staticmethod
         def get_validate_method_params():
             class ValidateMethodParams:
                 template_type = "Object"
             return ValidateMethodParams
 
         @staticmethod
         def get_output_pass_model():
             return RawTypes.OutputPassModel.ByReference
 
         @staticmethod
         def is_heavy_value():
             return True
 
         @staticmethod
         def get_array_item_raw_c_type_text():
-            return "InspectorObject"
+            return "JSONObject"
 
         @staticmethod
         def get_raw_type_model():
             return TypeModel.Object
 
     class Any(BaseType):
         @staticmethod
         def get_getter_name():
             return "Value"
 
         get_setter_name = get_getter_name
 
         @staticmethod
         def get_c_initializer():
             raise Exception("Unsupported")
 
         @staticmethod
+        def get_constructor_pattern():
+            raise Exception("Unsupported")
+
+        @staticmethod
         def get_raw_validator_call_text():
             return "RuntimeCastHelper::assertAny"
 
         @staticmethod
         def get_output_pass_model():
             return RawTypes.OutputPassModel.ByReference
 
         @staticmethod
         def is_heavy_value():
             return True
 
         @staticmethod
         def get_array_item_raw_c_type_text():
-            return "InspectorValue"
+            return "JSONValue"
 
         @staticmethod
         def get_raw_type_model():
             return TypeModel.Any
 
     class Array(BaseType):
         @staticmethod
         def get_getter_name():
             return "Array"
 
         @staticmethod
         def get_setter_name():
             return "Value"
 
         @staticmethod
+        def get_constructor_pattern():
+            return "%s"
+
+        @staticmethod
         def get_c_initializer():
-            return "InspectorArray::create()"
+            return "JSONArray::create()"
 
         @staticmethod
         def get_output_argument_prefix():
             return ""
 
         @staticmethod
         def get_validate_method_params():
             class ValidateMethodParams:
                 template_type = "Array"
             return ValidateMethodParams
 
         @staticmethod
         def get_output_pass_model():
             return RawTypes.OutputPassModel.ByReference
 
         @staticmethod
         def is_heavy_value():
             return True
 
         @staticmethod
         def get_array_item_raw_c_type_text():
-            return "InspectorArray"
+            return "JSONArray"
 
         @staticmethod
         def get_raw_type_model():
             return TypeModel.Array
 
 
 def replace_right_shift(input_str):
     return input_str.replace(">>", "> >")
 
 
@@ skipping 176 matching lines @@
 
     @classmethod
     def init_class(cls):
         cls.Bool = cls.ValueType("bool", False)
         if EXACTLY_INT_SUPPORTED:
             cls.Int = cls.ExactlyInt()
         else:
             cls.Int = cls.ValueType("int", False)
         cls.Number = cls.ValueType("double", False)
         cls.String = cls.ValueType("String", True,)
-        cls.Object = cls.RefPtrBased("InspectorObject")
-        cls.Array = cls.RefPtrBased("InspectorArray")
-        cls.Any = cls.RefPtrBased("InspectorValue")
+        cls.Object = cls.RefPtrBased("JSONObject")
+        cls.Array = cls.RefPtrBased("JSONArray")
+        cls.Any = cls.RefPtrBased("JSONValue")
 
 TypeModel.init_class()
 
 
-# Collection of InspectorObject class methods that are likely to be overloaded in generated class.
+# Collection of JSONObject class methods that are likely to be overloaded in generated class.
 # We must explicitly import all overloaded methods or they won't be available to user.
 INSPECTOR_OBJECT_SETTER_NAMES = frozenset(["setValue", "setBoolean", "setNumber", "setString", "setValue", "setObject", "setArray"])
 
 
 def fix_type_name(json_name):
     if json_name in TYPE_NAME_FIX_MAP:
         fixed = TYPE_NAME_FIX_MAP[json_name]
 
         class Result(object):
             class_name = fixed
@@ skipping 175 matching lines @@
                                     writer.append(item_c_name)
                                     writer.append(" = ")
                                     writer.append("%s" % enum_pos)
                                     writer.append(",\n")
                                 writer.newline("    };\n")
                                 if enum_binding_cls.need_user_runtime_cast_:
                                     raise Exception("Not yet implemented")
 
                                 if enum_binding_cls.need_internal_runtime_cast_:
                                     writer.append("#if %s\n" % VALIDATOR_IFDEF_NAME)
-                                    writer.newline("    static void assertCorrectValue(InspectorValue* value);\n")
+                                    writer.newline("    static void assertCorrectValue(JSONValue* value);\n")
                                     writer.append("#endif  // %s\n" % VALIDATOR_IFDEF_NAME)
 
                                     validator_writer = generate_context.validator_writer
 
                                     domain_fixes = DomainNameFixes.get_fixed_data(context_domain_name)
 
-                                    validator_writer.newline("void %s%s::assertCorrectValue(InspectorValue* value)\n" % (helper.full_name_prefix_for_impl, enum_name))
+                                    validator_writer.newline("void %s%s::assertCorrectValue(JSONValue* value)\n" % (helper.full_name_prefix_for_impl, enum_name))
                                     validator_writer.newline("{\n")
                                     validator_writer.newline("    WTF::String s;\n")
                                     validator_writer.newline("    bool cast_res = value->asString(&s);\n")
                                     validator_writer.newline("    ASSERT(cast_res);\n")
                                     if len(enum) > 0:
                                         condition_list = []
                                         for enum_item in enum:
                                             enum_pos = EnumConstants.add_constant(enum_item)
                                             condition_list.append("s == \"%s\"" % enum_item)
                                         validator_writer.newline("    ASSERT(%s);\n" % " || ".join(condition_list))
@@ skipping 125 matching lines @@
                         @staticmethod
                         def get_type_model():
                             return TypeModel.ValueType("%s%s" % (helper.full_name_prefix_for_use, fixed_type_name.class_name), True)
 
                         @staticmethod
                         def get_setter_value_expression_pattern():
                             return None
 
                         @classmethod
                         def get_array_item_c_type_text(cls):
-                            return "const %s%s&" % (helper.full_name_prefix_for_use, fixed_type_name.class_name)
+                            return "%s%s" % (helper.full_name_prefix_for_use, fixed_type_name.class_name)
 
                     return TypedefString
 
         elif json_typable["type"] == "object":
             if "properties" in json_typable:
 
                 class ClassBinding:
                     resolve_data_ = None
                     need_user_runtime_cast_ = False
                     need_internal_runtime_cast_ = False
@@ skipping 64 matching lines @@
                                 helper.write_doc(writer)
                                 class_name = fixed_type_name.class_name
 
                                 is_open_type = (context_domain_name + "." + class_name) in TYPES_WITH_OPEN_FIELD_LIST_SET
 
                                 fixed_type_name.output_comment(writer)
                                 writer.newline("class ")
                                 writer.append(class_name)
                                 writer.append(" : public ")
                                 if is_open_type:
-                                    writer.append("InspectorObject")
+                                    writer.append("JSONObject")
                                 else:
-                                    writer.append("InspectorObjectBase")
+                                    writer.append("JSONObjectBase")
                                 writer.append(" {\n")
                                 writer.newline("public:\n")
                                 ad_hoc_type_writer = writer.insert_writer("    ")
 
                                 for ad_hoc_type in resolve_data.ad_hoc_types:
                                     code_generator = ad_hoc_type.get_code_generator()
                                     if code_generator:
                                         code_generator.generate_type_builder(ad_hoc_type_writer, generate_context)
 
                                 writer.newline_multiline(
@@ skipping 56 matching lines @@
                                     writer.append_multiline("\n    void %s" % setter_name)
                                     writer.append("(%s value)\n" % param_type_binding.get_type_model().get_input_param_type_text())
                                     writer.newline("    {\n")
                                     writer.newline("        this->set%s(\"%s\", %s);\n"
                                         % (param_type_binding.reduce_to_raw_type().get_setter_name(), prop_data.p["name"],
                                            format_setter_value_expression(param_type_binding, "value")))
                                     writer.newline("    }\n")
 
 
                                     if setter_name in INSPECTOR_OBJECT_SETTER_NAMES:
-                                        writer.newline("    using InspectorObjectBase::%s;\n\n" % setter_name)
+                                        writer.newline("    using JSONObjectBase::%s;\n\n" % setter_name)
 
                                 if class_binding_cls.need_user_runtime_cast_:
-                                    writer.newline("    static PassRefPtr<%s> runtimeCast(PassRefPtr<InspectorValue> value)\n" % class_name)
+                                    writer.newline("    static PassRefPtr<%s> runtimeCast(PassRefPtr<JSONValue> value)\n" % class_name)
                                     writer.newline("    {\n")
-                                    writer.newline("        RefPtr<InspectorObject> object;\n")
+                                    writer.newline("        RefPtr<JSONObject> object;\n")
                                     writer.newline("        bool castRes = value->asObject(&object);\n")
                                     writer.newline("        ASSERT_UNUSED(castRes, castRes);\n")
                                     writer.append("#if %s\n" % VALIDATOR_IFDEF_NAME)
                                     writer.newline("        assertCorrectValue(object.get());\n")
                                     writer.append("#endif  // %s\n" % VALIDATOR_IFDEF_NAME)
-                                    writer.newline("        COMPILE_ASSERT(sizeof(%s) == sizeof(InspectorObjectBase), type_cast_problem);\n" % class_name)
-                                    writer.newline("        return static_cast<%s*>(static_cast<InspectorObjectBase*>(object.get()));\n" % class_name)
+                                    writer.newline("        COMPILE_ASSERT(sizeof(%s) == sizeof(JSONObjectBase), type_cast_problem);\n" % class_name)
+                                    writer.newline("        return static_cast<%s*>(static_cast<JSONObjectBase*>(object.get()));\n" % class_name)
                                     writer.newline("    }\n")
                                     writer.append("\n")
 
                                 if class_binding_cls.need_internal_runtime_cast_:
                                     writer.append("#if %s\n" % VALIDATOR_IFDEF_NAME)
-                                    writer.newline("    static void assertCorrectValue(InspectorValue* value);\n")
+                                    writer.newline("    static void assertCorrectValue(JSONValue* value);\n")
                                     writer.append("#endif  // %s\n" % VALIDATOR_IFDEF_NAME)
 
                                     closed_field_set = (context_domain_name + "." + class_name) not in TYPES_WITH_OPEN_FIELD_LIST_SET
 
                                     validator_writer = generate_context.validator_writer
 
                                     domain_fixes = DomainNameFixes.get_fixed_data(context_domain_name)
 
-                                    validator_writer.newline("void %s%s::assertCorrectValue(InspectorValue* value)\n" % (helper.full_name_prefix_for_impl, class_name))
+                                    validator_writer.newline("void %s%s::assertCorrectValue(JSONValue* value)\n" % (helper.full_name_prefix_for_impl, class_name))
                                     validator_writer.newline("{\n")
-                                    validator_writer.newline("    RefPtr<InspectorObject> object;\n")
+                                    validator_writer.newline("    RefPtr<JSONObject> object;\n")
                                     validator_writer.newline("    bool castRes = value->asObject(&object);\n")
                                     validator_writer.newline("    ASSERT_UNUSED(castRes, castRes);\n")
                                     for prop_data in resolve_data.main_properties:
                                         validator_writer.newline("    {\n")
                                         it_name = "%sPos" % prop_data.p["name"]
-                                        validator_writer.newline("        InspectorObject::iterator %s;\n" % it_name)
+                                        validator_writer.newline("        JSONObject::iterator %s;\n" % it_name)
                                         validator_writer.newline("        %s = object->find(\"%s\");\n" % (it_name, prop_data.p["name"]))
                                         validator_writer.newline("        ASSERT(%s != object->end());\n" % it_name)
                                         validator_writer.newline("        %s(%s->value.get());\n" % (prop_data.param_type_binding.get_validator_call_text(), it_name))
                                         validator_writer.newline("    }\n")
 
                                     if closed_field_set:
                                         validator_writer.newline("    int foundPropertiesCount = %s;\n" % len(resolve_data.main_properties))
 
                                     for prop_data in resolve_data.optional_properties:
                                         validator_writer.newline("    {\n")
                                         it_name = "%sPos" % prop_data.p["name"]
-                                        validator_writer.newline("        InspectorObject::iterator %s;\n" % it_name)
+                                        validator_writer.newline("        JSONObject::iterator %s;\n" % it_name)
                                         validator_writer.newline("        %s = object->find(\"%s\");\n" % (it_name, prop_data.p["name"]))
                                         validator_writer.newline("        if (%s != object->end()) {\n" % it_name)
                                         validator_writer.newline("            %s(%s->value.get());\n" % (prop_data.param_type_binding.get_validator_call_text(), it_name))
                                         if closed_field_set:
                                             validator_writer.newline("            ++foundPropertiesCount;\n")
                                         validator_writer.newline("        }\n")
                                         validator_writer.newline("    }\n")
 
                                     if closed_field_set:
                                         validator_writer.newline("    if (foundPropertiesCount != object->size()) {\n")
@@ skipping 90 matching lines @@
                     @staticmethod
                     def request_internal_runtime_cast():
                         RawTypes.Object.request_raw_internal_runtime_cast()
 
                     @staticmethod
                     def get_code_generator():
                         pass
 
                     @staticmethod
                     def get_validator_call_text():
-                        return "RuntimeCastHelper::assertType<InspectorValue::TypeObject>"
+                        return "RuntimeCastHelper::assertType<JSONValue::TypeObject>"
 
                     @classmethod
                     def get_array_item_c_type_text(cls):
                         return cls.reduce_to_raw_type().get_array_item_raw_c_type_text()
 
                     @staticmethod
                     def get_setter_value_expression_pattern():
                         return None
 
                     @staticmethod
@@ skipping 289 matching lines @@
 
     file_header_ = ("// File is generated by %s\n\n" % get_this_script_path_(sys.argv[0]) +
 """// Copyright (c) 2011 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.
 """)
 
     frontend_domain_class = string.Template(CodeGeneratorInspectorStrings.frontend_domain_class)
     backend_method = string.Template(CodeGeneratorInspectorStrings.backend_method)
     frontend_method = string.Template(CodeGeneratorInspectorStrings.frontend_method)
-    callback_method = string.Template(CodeGeneratorInspectorStrings.callback_method)
+    callback_main_methods = string.Template(CodeGeneratorInspectorStrings.callback_main_methods)
+    callback_failure_method = string.Template(CodeGeneratorInspectorStrings.callback_failure_method)
     frontend_h = string.Template(file_header_ + CodeGeneratorInspectorStrings.frontend_h)
     backend_h = string.Template(file_header_ + CodeGeneratorInspectorStrings.backend_h)
     backend_cpp = string.Template(file_header_ + CodeGeneratorInspectorStrings.backend_cpp)
     frontend_cpp = string.Template(file_header_ + CodeGeneratorInspectorStrings.frontend_cpp)
     typebuilder_h = string.Template(file_header_ + CodeGeneratorInspectorStrings.typebuilder_h)
     typebuilder_cpp = string.Template(file_header_ + CodeGeneratorInspectorStrings.typebuilder_cpp)
     param_container_access_code = CodeGeneratorInspectorStrings.param_container_access_code
 
 
 
@@ skipping 168 matching lines @@
                                        decl_parameter_list,
                                        Generator.EventMethodStructTemplate,
                                        Generator.frontend_method_list, Templates.frontend_method, {"eventName": event_name})
 
         frontend_method_declaration_lines.append(
             "        void %s(%s);\n" % (event_name, ", ".join(decl_parameter_list)))
 
     class EventMethodStructTemplate:
         @staticmethod
         def append_prolog(line_list):
-            line_list.append("    RefPtr<InspectorObject> paramsObject = InspectorObject::create();\n")
+            line_list.append("    RefPtr<JSONObject> paramsObject = JSONObject::create();\n")
 
         @staticmethod
         def append_epilog(line_list):
             line_list.append("    jsonMessage->setObject(\"params\", paramsObject);\n")
 
         container_name = "paramsObject"
 
     @staticmethod
     def process_command(json_command, domain_name, agent_field_name, agent_interface_name):
         json_command_name = json_command["name"]
 
         cmd_enum_name = "k%s_%sCmd" % (domain_name, json_command["name"])
 
         Generator.method_name_enum_list.append("        %s," % cmd_enum_name)
         Generator.method_handler_list.append("            &InspectorBackendDispatcherImpl::%s_%s," % (domain_name, json_command_name))
-        Generator.backend_method_declaration_list.append("    void %s_%s(long callId, InspectorObject* requestMessageObject);" % (domain_name, json_command_name))
+        Generator.backend_method_declaration_list.append("    void %s_%s(long callId, JSONObject* requestMessageObject);" % (domain_name, json_command_name))
 
         ad_hoc_type_output = []
         Generator.backend_agent_interface_list.append(ad_hoc_type_output)
         ad_hoc_type_writer = Writer(ad_hoc_type_output, "        ")
 
         Generator.backend_agent_interface_list.append("        virtual void %s(ErrorString*" % json_command_name)
 
         method_in_code = ""
         method_out_code = ""
         agent_call_param_list = []
-        response_cook_list = []
         request_message_param = ""
+        normal_response_cook_text = ""
+        error_response_cook_text = ""
+        error_type_binding = None
+        if "error" in json_command:
+            json_error = json_command["error"]
+            error_type_binding = Generator.resolve_type_and_generate_ad_hoc(json_error, json_command_name + "Error", json_command_name, domain_name, ad_hoc_type_writer, agent_interface_name + "::")
+            error_type_model = error_type_binding.get_type_model().get_optional()
+            error_annotated_type = error_type_model.get_command_return_pass_model().get_output_parameter_type()
+            agent_call_param_list.append(", %serrorData" % error_type_model.get_command_return_pass_model().get_output_argument_prefix())
+            Generator.backend_agent_interface_list.append(", %s errorData" % error_annotated_type)
+            method_in_code += "    %s errorData;\n" % error_type_model.get_command_return_pass_model().get_return_var_type()
+
+            setter_argument = error_type_model.get_command_return_pass_model().get_output_to_raw_expression() % "errorData"
+            if error_type_binding.get_setter_value_expression_pattern():
+                setter_argument = error_type_binding.get_setter_value_expression_pattern() % setter_argument
+            error_assigment_value = error_type_binding.reduce_to_raw_type().get_constructor_pattern() % setter_argument
+
+            cook = "            resultErrorData = %s;\n" % error_assigment_value
+
+            error_condition_pattern = error_type_model.get_command_return_pass_model().get_set_return_condition()
+            cook = ("            if (%s)\n    " % (error_condition_pattern % "errorData")) + cook
+            error_response_cook_text = "        if (error.length()) {\n" + cook + "        }\n"
+
         if "parameters" in json_command:
             json_params = json_command["parameters"]
             method_in_code += Templates.param_container_access_code
             request_message_param = " requestMessageObject"
-            js_param_list = []
 
             for json_parameter in json_params:
                 json_param_name = json_parameter["name"]
                 param_raw_type = resolve_param_raw_type(json_parameter, domain_name)
 
                 getter_name = param_raw_type.get_getter_name()
 
                 optional = json_parameter.get("optional")
 
                 non_optional_type_model = param_raw_type.get_raw_type_model()
@@ skipping 16 matching lines @@
                     # FIXME: pass not-optional refptr-values as NonNullPassRefPtr
                     if param_raw_type.is_heavy_value():
                         formal_param_type_pattern = "const %s&"
                     else:
                         formal_param_type_pattern = "%s"
 
                 method_in_code += code
                 agent_call_param_list.append(param)
                 Generator.backend_agent_interface_list.append(", %s in_%s" % (formal_param_type_pattern % non_optional_type_model.get_command_return_pass_model().get_return_var_type(), json_param_name))
 
-        response_cook_text = ""
         if json_command.get("async") == True:
             callback_name = Capitalizer.lower_camel_case_to_upper(json_command_name) + "Callback"
 
             callback_output = []
             callback_writer = Writer(callback_output, ad_hoc_type_writer.get_indent())
 
             decl_parameter_list = []
             Generator.generate_send_method(json_command.get("returns"), json_command_name, domain_name, ad_hoc_type_writer,
                                            decl_parameter_list,
                                            Generator.CallbackMethodStructTemplate,
-                                           Generator.backend_method_implementation_list, Templates.callback_method,
+                                           Generator.backend_method_implementation_list, Templates.callback_main_methods,
                                            {"callbackName": callback_name, "agentName": agent_interface_name})
 
             callback_writer.newline("class " + callback_name + " : public CallbackBase {\n")
             callback_writer.newline("public:\n")
             callback_writer.newline("    " + callback_name + "(PassRefPtr<InspectorBackendDispatcherImpl>, int id);\n")
             callback_writer.newline("    void sendSuccess(" + ", ".join(decl_parameter_list) + ");\n")
+            error_part_writer = callback_writer.insert_writer("")
             callback_writer.newline("};\n")
 
+            if error_type_binding:
+                annotated_type = error_type_model.get_input_param_type_text()
+                error_part_writer.newline("    void sendFailure(const ErrorString&, %s);\n" % annotated_type)
+                error_part_writer.newline("    using CallbackBase::sendFailure;\n")
+
+                assigment_value = error_type_model.get_event_setter_expression_pattern() % "errorData"
+                assigment_value = error_type_binding.reduce_to_raw_type().get_constructor_pattern() % assigment_value
+
+                Generator.backend_method_implementation_list.append(Templates.callback_failure_method.substitute(None,
+                    agentName=agent_interface_name,
+                    callbackName=callback_name,
+                    parameter=annotated_type + " errorData",
+                    argument=assigment_value))
+
+
+
             ad_hoc_type_output.append(callback_output)
 
             method_out_code += "    RefPtr<" + agent_interface_name + "::" + callback_name + "> callback = adoptRef(new " + agent_interface_name + "::" + callback_name + "(this, callId));\n"
             agent_call_param_list.append(", callback")
-            response_cook_text += "        if (!error.length()) \n"
-            response_cook_text += "            return;\n"
-            response_cook_text += "        callback->disable();\n"
+            normal_response_cook_text += "        if (!error.length()) \n"
+            normal_response_cook_text += "            return;\n"
+            normal_response_cook_text += "        callback->disable();\n"
             Generator.backend_agent_interface_list.append(", PassRefPtr<%s> callback" % callback_name)
         else:
             if "returns" in json_command:
                 method_out_code += "\n"
+                response_cook_list = []
                 for json_return in json_command["returns"]:
 
                     json_return_name = json_return["name"]
 
                     optional = bool(json_return.get("optional"))
 
-                    return_type_binding = Generator.resolve_type_and_generate_ad_hoc(json_return, json_command_name, domain_name, ad_hoc_type_writer, agent_interface_name + "::")
+                    return_type_binding = Generator.resolve_param_type_and_generate_ad_hoc(json_return, json_command_name, domain_name, ad_hoc_type_writer, agent_interface_name + "::")
 
                     raw_type = return_type_binding.reduce_to_raw_type()
                     setter_type = raw_type.get_setter_name()
                     initializer = raw_type.get_c_initializer()
 
                     type_model = return_type_binding.get_type_model()
                     if optional:
                         type_model = type_model.get_optional()
 
                     code = "    %s out_%s;\n" % (type_model.get_command_return_pass_model().get_return_var_type(), json_return_name)
                     param = ", %sout_%s" % (type_model.get_command_return_pass_model().get_output_argument_prefix(), json_return_name)
                     var_name = "out_%s" % json_return_name
                     setter_argument = type_model.get_command_return_pass_model().get_output_to_raw_expression() % var_name
                     if return_type_binding.get_setter_value_expression_pattern():
                         setter_argument = return_type_binding.get_setter_value_expression_pattern() % setter_argument
 
                     cook = "            result->set%s(\"%s\", %s);\n" % (setter_type, json_return_name,
                                                                          setter_argument)
 
                     set_condition_pattern = type_model.get_command_return_pass_model().get_set_return_condition()
                     if set_condition_pattern:
                         cook = ("            if (%s)\n    " % (set_condition_pattern % var_name)) + cook
                     annotated_type = type_model.get_command_return_pass_model().get_output_parameter_type()
 
-                    param_name = "out_%s" % json_return_name
+                    param_name = var_name
                     if optional:
                         param_name = "opt_" + param_name
 
                     Generator.backend_agent_interface_list.append(", %s %s" % (annotated_type, param_name))
                     response_cook_list.append(cook)
 
                     method_out_code += code
                     agent_call_param_list.append(param)
 
-                response_cook_text = "".join(response_cook_list)
+                normal_response_cook_text += "".join(response_cook_list)
 
-                if len(response_cook_text) != 0:
-                    response_cook_text = "        if (!error.length()) {\n" + response_cook_text + "        }"
+                if len(normal_response_cook_text) != 0:
+                    normal_response_cook_text = "        if (!error.length()) {\n" + normal_response_cook_text + "        }"
 
         Generator.backend_method_implementation_list.append(Templates.backend_method.substitute(None,
             domainName=domain_name, methodName=json_command_name,
             agentField="m_" + agent_field_name,
             methodInCode=method_in_code,
             methodOutCode=method_out_code,
             agentCallParams="".join(agent_call_param_list),
             requestMessageObject=request_message_param,
-            responseCook=response_cook_text,
+            responseCook=normal_response_cook_text,
+            errorCook=error_response_cook_text,
             commandNameIndex=cmd_enum_name))
         Generator.backend_method_name_declaration_list.append("    \"%s.%s\"," % (domain_name, json_command_name))
 
         Generator.backend_agent_interface_list.append(") = 0;\n")
 
     class CallbackMethodStructTemplate:
         @staticmethod
         def append_prolog(line_list):
             pass
 
         @staticmethod
         def append_epilog(line_list):
             pass
 
         container_name = "jsonMessage"
 
     # Generates common code for event sending and callback response data sending.
     @staticmethod
     def generate_send_method(parameters, event_name, domain_name, ad_hoc_type_writer, decl_parameter_list,
                              method_struct_template,
                              generator_method_list, method_template, template_params):
         method_line_list = []
         if parameters:
             method_struct_template.append_prolog(method_line_list)
             for json_parameter in parameters:
                 parameter_name = json_parameter["name"]
 
-                param_type_binding = Generator.resolve_type_and_generate_ad_hoc(json_parameter, event_name, domain_name, ad_hoc_type_writer, "")
+                param_type_binding = Generator.resolve_param_type_and_generate_ad_hoc(json_parameter, event_name, domain_name, ad_hoc_type_writer, "")
 
                 raw_type = param_type_binding.reduce_to_raw_type()
                 raw_type_binding = RawTypeBinding(raw_type)
 
                 optional = bool(json_parameter.get("optional"))
 
                 setter_type = raw_type.get_setter_name()
 
                 type_model = param_type_binding.get_type_model()
                 raw_type_model = raw_type_binding.get_type_model()
@@ skipping 15 matching lines @@
                     setter_code = ("    if (%s)\n    " % parameter_name) + setter_code
                 method_line_list.append(setter_code)
 
             method_struct_template.append_epilog(method_line_list)
 
         generator_method_list.append(method_template.substitute(None,
             domainName=domain_name,
             parameters=", ".join(decl_parameter_list),
             code="".join(method_line_list), **template_params))
 
+    @classmethod
+    def resolve_param_type_and_generate_ad_hoc(cls, json_param, method_name, domain_name, ad_hoc_type_writer, container_relative_name_prefix_param):
+        param_name = json_param["name"]
+        return cls.resolve_type_and_generate_ad_hoc(json_param, param_name, method_name, domain_name, ad_hoc_type_writer, container_relative_name_prefix_param)
+
     @staticmethod
-    def resolve_type_and_generate_ad_hoc(json_param, method_name, domain_name, ad_hoc_type_writer, container_relative_name_prefix_param):
-        param_name = json_param["name"]
+    def resolve_type_and_generate_ad_hoc(typable_element, element_name, method_name, domain_name, ad_hoc_type_writer, container_relative_name_prefix_param):
         ad_hoc_type_list = []
 
         class AdHocTypeContext:
             container_full_name_prefix = "<not yet defined>"
             container_relative_name_prefix = container_relative_name_prefix_param
 
             @staticmethod
             def get_type_name_fix():
                 class NameFix:
-                    class_name = Capitalizer.lower_camel_case_to_upper(param_name)
+                    class_name = Capitalizer.lower_camel_case_to_upper(element_name)
 
                     @staticmethod
                     def output_comment(writer):
-                        writer.newline("// Named after parameter '%s' while generating command/event %s.\n" % (param_name, method_name))
+                        writer.newline("// Named after parameter '%s' while generating command/event %s.\n" % (element_name, method_name))
 
                 return NameFix
 
             @staticmethod
             def add_type(binding):
                 ad_hoc_type_list.append(binding)
 
-        type_binding = resolve_param_type(json_param, domain_name, AdHocTypeContext)
+        type_binding = resolve_param_type(typable_element, domain_name, AdHocTypeContext)
 
         class InterfaceForwardListener:
             @staticmethod
             def add_type_data(type_data):
                 pass
 
         class InterfaceResolveContext:
             forward_listener = InterfaceForwardListener
 
         for type in ad_hoc_type_list:
@@ skipping 164 matching lines @@
     validatorIfdefName=VALIDATOR_IFDEF_NAME))
 
 backend_h_file.close()
 backend_cpp_file.close()
 
 frontend_h_file.close()
 frontend_cpp_file.close()
 
 typebuilder_h_file.close()
 typebuilder_cpp_file.close()