Update IDL to 1847

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 31 matching lines @@
 
 # Manually-filled map of type name replacements.
 TYPE_NAME_FIX_MAP = {
     "RGBA": "Rgba",  # RGBA is reported to be conflicting with a define name in Windows CE.
     "": "Empty",
 }
 
 
 TYPES_WITH_RUNTIME_CAST_SET = frozenset(["Runtime.RemoteObject", "Runtime.PropertyDescriptor", "Runtime.InternalPropertyDescriptor",
                                          "Debugger.FunctionDetails", "Debugger.CallFrame", "Debugger.Location",
-                                         "Canvas.TraceLog", "Canvas.ResourceState",
-                                         # This should be a temporary hack. TimelineEvent should be created via generated C++ API.
-                                         "Timeline.TimelineEvent"])
+                                         "Canvas.TraceLog", "Canvas.ResourceState"])
 
-TYPES_WITH_OPEN_FIELD_LIST_SET = frozenset(["Timeline.TimelineEvent",
+TYPES_WITH_OPEN_FIELD_LIST_SET = frozenset([
                                             # InspectorStyleSheet not only creates this property but wants to read it and modify it.
                                             "CSS.CSSProperty",
                                             # InspectorResourceAgent needs to update mime-type.
                                             "Network.Response"])
 
 EXACTLY_INT_SUPPORTED = False
 
 cmdline_parser = optparse.OptionParser()
 cmdline_parser.add_option("--output_dir")
 
@@ skipping 1815 matching lines @@
     @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, JSONObject* requestMessageObject);" % (domain_name, json_command_name))
 
+        backend_agent_interface_list = [] if "redirect" in json_command else Generator.backend_agent_interface_list
+
         ad_hoc_type_output = []
-        Generator.backend_agent_interface_list.append(ad_hoc_type_output)
+        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)
+        backend_agent_interface_list.append("        virtual void %s(ErrorString*" % json_command_name)
 
         method_in_code = ""
         method_out_code = ""
         agent_call_param_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)
+            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()
@@ skipping 33 matching lines @@
                             (non_optional_type_model.get_command_return_pass_model().get_return_var_type(), json_param_name, getter_name, json_param_name))
                     param = ", in_%s" % json_param_name
                     # 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))
+                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))
 
         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,
@@ skipping 24 matching lines @@
 
 
 
             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")
             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)
+            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"))
 
@@ skipping 19 matching lines @@
 
                     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 = var_name
                     if optional:
                         param_name = "opt_" + param_name
 
-                    Generator.backend_agent_interface_list.append(", %s %s" % (annotated_type, param_name))
+                    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)
 
                 normal_response_cook_text += "".join(response_cook_list)
 
                 if len(normal_response_cook_text) != 0:
                     normal_response_cook_text = "        if (!error.length()) {\n" + normal_response_cook_text + "        }"
 
+        # Redirect to another agent's implementation.
+        agent_field = "m_" + agent_field_name
+        if "redirect" in json_command:
+            domain_fixes = DomainNameFixes.get_fixed_data(json_command.get("redirect"))
+            agent_field = "m_" + domain_fixes.agent_field_name
+
         Generator.backend_method_implementation_list.append(Templates.backend_method.substitute(None,
             domainName=domain_name, methodName=json_command_name,
-            agentField="m_" + agent_field_name,
+            agentField=agent_field,
             methodInCode=method_in_code,
             methodOutCode=method_out_code,
             agentCallParams="".join(agent_call_param_list),
             requestMessageObject=request_message_param,
             responseCook=normal_response_cook_text,
             errorCook=error_response_cook_text,
             commandNameIndex=cmd_enum_name))
         declaration_command_name = "%s.%s\\0" % (domain_name, json_command_name)
         Generator.backend_method_name_declaration_list.append("    \"%s\"" % declaration_command_name)
         Generator.backend_method_name_declaration_index_list.append("    %d," % Generator.backend_method_name_declaration_current_index)
         Generator.backend_method_name_declaration_current_index += len(declaration_command_name) - 1
 
-        Generator.backend_agent_interface_list.append(") = 0;\n")
+        backend_agent_interface_list.append(") = 0;\n")
 
     class CallbackMethodStructTemplate:
         @staticmethod
         def append_prolog(line_list):
             pass
 
         @staticmethod
         def append_epilog(line_list):
             pass
 
@@ skipping 253 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()