Move IDLs to 39 roll

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 30 matching lines @@
 import CodeGeneratorInspectorStrings
 
 # 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",
+                                         "Debugger.FunctionDetails", "Debugger.CollectionEntry", "Debugger.CallFrame", "Debugger.Location",
                                          "Canvas.TraceLog", "Canvas.ResourceState"])
 
 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")
 
 try:
     arg_options, arg_values = cmdline_parser.parse_args()
     if (len(arg_values) != 1):
         raise Exception("Exactly one plain argument expected (found %s)" % len(arg_values))
     input_json_filename = arg_values[0]
     output_dirname = arg_options.output_dir
     if not output_dirname:
@@ skipping 38 matching lines @@
         if pos == 1:
             return str[0].lower() + str[1:]
         if pos < len(str):
             pos -= 1
         possible_abbreviation = str[0:pos]
         if possible_abbreviation not in Capitalizer.ABBREVIATION:
             raise Exception("Unknown abbreviation %s" % possible_abbreviation)
         str = possible_abbreviation.lower() + str[pos:]
         return str
 
-    @staticmethod
-    def camel_case_to_capitalized_with_underscores(str):
-        if len(str) == 0:
-            return str
-        output = Capitalizer.split_camel_case_(str)
-        return "_".join(output).upper()
-
-    @staticmethod
-    def split_camel_case_(str):
-        output = []
-        pos_being = 0
-        pos = 1
-        has_oneletter = False
-        while pos < len(str):
-            if str[pos].isupper():
-                output.append(str[pos_being:pos].upper())
-                if pos - pos_being == 1:
-                    has_oneletter = True
-                pos_being = pos
-            pos += 1
-        output.append(str[pos_being:])
-        if has_oneletter:
-            array_pos = 0
-            while array_pos < len(output) - 1:
-                if len(output[array_pos]) == 1:
-                    array_pos_end = array_pos + 1
-                    while array_pos_end < len(output) and len(output[array_pos_end]) == 1:
-                        array_pos_end += 1
-                    if array_pos_end - array_pos > 1:
-                        possible_abbreviation = "".join(output[array_pos:array_pos_end])
-                        if possible_abbreviation.upper() in Capitalizer.ABBREVIATION:
-                            output[array_pos:array_pos_end] = [possible_abbreviation]
-                        else:
-                            array_pos = array_pos_end - 1
-                array_pos += 1
-        return output
-
     ABBREVIATION = frozenset(["XHR", "DOM", "CSS"])
 
 VALIDATOR_IFDEF_NAME = "ENABLE(ASSERT)"
 
 
 class DomainNameFixes:
-    @classmethod
-    def get_fixed_data(cls, domain_name):
-        field_name_res = Capitalizer.upper_camel_case_to_lower(domain_name) + "Agent"
-
-        class Res(object):
-            agent_field_name = field_name_res
-
-        return Res
-
+    @staticmethod
+    def get_fixed_data(domain_name):
+        return Capitalizer.upper_camel_case_to_lower(domain_name) + "Agent"
 
 class RawTypes(object):
     @staticmethod
     def get(json_type):
         if json_type == "boolean":
             return RawTypes.Bool
         elif json_type == "string":
             return RawTypes.String
         elif json_type == "array":
             return RawTypes.Array
         elif json_type == "object":
             return RawTypes.Object
         elif json_type == "integer":
             return RawTypes.Int
         elif json_type == "number":
             return RawTypes.Number
         elif json_type == "any":
             return RawTypes.Any
         else:
             raise Exception("Unknown type: %s" % json_type)
 
-    # For output parameter all values are passed by pointer except RefPtr-based types.
-    class OutputPassModel:
-        class ByPointer:
-            @staticmethod
-            def get_argument_prefix():
-                return "&"
-
-            @staticmethod
-            def get_parameter_type_suffix():
-                return "*"
-
-        class ByReference:
-            @staticmethod
-            def get_argument_prefix():
-                return ""
-
-            @staticmethod
-            def get_parameter_type_suffix():
-                return "&"
-
     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<JSONValue::Type%s>" % cls.get_validate_method_params().template_type
+            return "RuntimeCastHelper::assertType<JSONValue::Type%s>" % cls.get_getter_name()
 
         @staticmethod
-        def get_validate_method_params():
-            raise Exception("Abstract method")
+        def get_getter_name():
+            raise Exception("Unsupported")
 
     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
-        def get_output_pass_model():
-            return RawTypes.OutputPassModel.ByPointer
-
-        @staticmethod
         def is_heavy_value():
             return True
 
         @staticmethod
         def get_array_item_raw_c_type_text():
             return "String"
 
         @staticmethod
         def get_raw_type_model():
             return TypeModel.String
 
     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
-
-        @staticmethod
         def is_heavy_value():
             return False
 
         @staticmethod
         def get_array_item_raw_c_type_text():
             return "int"
 
         @staticmethod
         def get_raw_type_model():
             return TypeModel.Int
 
     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
-        def get_output_pass_model():
-            return RawTypes.OutputPassModel.ByPointer
+        def get_raw_validator_call_text():
+            return "RuntimeCastHelper::assertType<JSONValue::TypeNumber>"
 
         @staticmethod
         def is_heavy_value():
             return False
 
         @staticmethod
         def get_array_item_raw_c_type_text():
             return "double"
 
         @staticmethod
         def get_raw_type_model():
             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
-        def get_output_pass_model():
-            return RawTypes.OutputPassModel.ByPointer
-
-        @staticmethod
         def is_heavy_value():
             return False
 
         @staticmethod
         def get_array_item_raw_c_type_text():
             return "bool"
 
         @staticmethod
         def get_raw_type_model():
             return TypeModel.Bool
 
     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 "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 "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 "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 "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 "JSONArray"
 
         @staticmethod
         def get_raw_type_model():
             return TypeModel.Array
@@ skipping 163 matching lines @@
             def get_command_return_pass_model(self):
                 return CommandReturnPassModel.OptOutput(self.base.get_opt_output_type_())
 
             def get_input_param_type_text(self):
                 return "const %s* const" % self.base.type_name
 
             @staticmethod
             def get_event_setter_expression_pattern():
                 return "*%s"
 
-    class ExactlyInt(ValueType):
-        def __init__(self):
-            TypeModel.ValueType.__init__(self, "int", False)
-
-        def get_input_param_type_text(self):
-            return "TypeBuilder::ExactlyInt"
-
-        def get_opt_output_type_(self):
-            return "TypeBuilder::ExactlyInt"
-
     @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.Int = cls.ValueType("int", False)
         cls.Number = cls.ValueType("double", False)
         cls.String = cls.ValueType("String", True,)
         cls.Object = cls.RefPtrBased("JSONObject")
         cls.Array = cls.RefPtrBased("JSONArray")
         cls.Any = cls.RefPtrBased("JSONValue")
 
 TypeModel.init_class()
 
 
 # Collection of JSONObject class methods that are likely to be overloaded in generated class.
@@ skipping 48 matching lines @@
         parts = str.split('\n')
         self.append(parts[0])
         for p in parts[1:]:
             self.output.append('\n')
             if p:
                 self.newline(p)
 
     def get_indent(self):
         return self.indent
 
-    def get_indented(self, additional_indent):
-        return Writer(self.output, self.indent + additional_indent)
-
     def insert_writer(self, additional_indent):
         new_output = []
         self.output.append(new_output)
         return Writer(new_output, self.indent + additional_indent)
 
 
 class EnumConstants:
     map_ = {}
     constants_ = []
 
@@ skipping 82 matching lines @@
                         if request:
                             cls.need_user_runtime_cast_ = True
                             request.acknowledge()
 
                     @classmethod
                     def request_internal_runtime_cast(cls):
                         cls.need_internal_runtime_cast_ = True
 
                     @classmethod
                     def get_code_generator(enum_binding_cls):
-                        #FIXME: generate ad-hoc enums too once we figure out how to better implement them in C++.
-                        comment_out = helper.is_ad_hoc
 
                         class CodeGenerator:
                             @staticmethod
                             def generate_type_builder(writer, generate_context):
                                 enum = json_typable["enum"]
                                 helper.write_doc(writer)
                                 enum_name = fixed_type_name.class_name
                                 fixed_type_name.output_comment(writer)
                                 writer.newline("struct ")
                                 writer.append(enum_name)
@@ skipping 15 matching lines @@
                                 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(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(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)
@@ skipping 85 matching lines @@
                         @classmethod
                         def resolve_inner(cls, resolve_context):
                             pass
 
                         @staticmethod
                         def request_user_runtime_cast(request):
                             raise Exception("Unsupported")
 
                         @staticmethod
                         def request_internal_runtime_cast():
-                            RawTypes.String.request_raw_internal_runtime_cast()
+                            pass
 
                         @staticmethod
                         def get_code_generator():
                             class CodeGenerator:
                                 @staticmethod
                                 def generate_type_builder(writer, generate_context):
                                     helper.write_doc(writer)
                                     fixed_type_name.output_comment(writer)
                                     writer.newline("typedef String ")
                                     writer.append(fixed_type_name.class_name)
@@ skipping 172 matching lines @@
                                     writer.append_multiline("\n     *     .set%s(...)" % Capitalizer.lower_camel_case_to_upper(prop_data.p["name"]))
                                 writer.append_multiline(";\n     */\n")
 
                                 writer.newline_multiline(CodeGeneratorInspectorStrings.class_binding_builder_part_4)
 
                                 writer.newline("    typedef TypeBuilder::StructItemTraits ItemTraits;\n")
 
                                 for prop_data in resolve_data.main_properties:
                                     prop_name = prop_data.p["name"]
                                     param_type_binding = prop_data.param_type_binding
-                                    raw_type = param_type_binding.reduce_to_raw_type()
                                     if isinstance(param_type_binding.get_type_model(), TypeModel.ValueType):
                                         writer.append_multiline("\n    void %s" % prop_name)
                                         writer.append("(%s value)\n" % param_type_binding.get_type_model().get_command_return_pass_model().get_output_parameter_type())
                                         writer.newline("    {\n")
                                         writer.newline("        JSONObjectBase::get%s(\"%s\", value);\n"
                                             % (param_type_binding.reduce_to_raw_type().get_setter_name(), prop_data.p["name"]))
                                         writer.newline("    }\n")
 
                                 for prop_data in resolve_data.optional_properties:
                                     prop_name = prop_data.p["name"]
@@ skipping 27 matching lines @@
 
                                 if class_binding_cls.need_internal_runtime_cast_:
                                     writer.append("#if %s\n" % VALIDATOR_IFDEF_NAME)
                                     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(JSONValue* value)\n" % (helper.full_name_prefix_for_impl, class_name))
                                     validator_writer.newline("{\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("        JSONObject::iterator %s;\n" % it_name)
                                         validator_writer.newline("        %s = object->find(\"%s\");\n" % (it_name, prop_data.p["name"]))
@@ skipping 103 matching lines @@
                     @classmethod
                     def resolve_inner(cls, resolve_context):
                         pass
 
                     @staticmethod
                     def request_user_runtime_cast(request):
                         pass
 
                     @staticmethod
                     def request_internal_runtime_cast():
-                        RawTypes.Object.request_raw_internal_runtime_cast()
+                        pass
 
                     @staticmethod
                     def get_code_generator():
                         pass
 
                     @staticmethod
                     def get_validator_call_text():
                         return "RuntimeCastHelper::assertType<JSONValue::TypeObject>"
 
                     @classmethod
@@ skipping 126 matching lines @@
     def __init__(self, raw_type):
         self.raw_type_ = raw_type
 
     def resolve_inner(self, resolve_context):
         pass
 
     def request_user_runtime_cast(self, request):
         raise Exception("Unsupported")
 
     def request_internal_runtime_cast(self):
-        self.raw_type_.request_raw_internal_runtime_cast()
+        pass
 
     def get_code_generator(self):
         return None
 
     def get_validator_call_text(self):
         return self.raw_type_.get_raw_validator_call_text()
 
     def get_array_item_c_type_text(self):
         return self.raw_type_.get_array_item_raw_c_type_text()
 
@@ skipping 266 matching lines @@
     type_builder_fragments = []
     type_builder_forwards = []
     validator_impl_list = []
     type_builder_impl_list = []
 
 
     @staticmethod
     def go():
         Generator.process_types(type_map)
 
-        first_cycle_guardable_list_list = [
-            Generator.backend_method_declaration_list,
-            Generator.backend_method_implementation_list,
-            Generator.backend_method_name_declaration_list,
-            Generator.backend_method_name_declaration_index_list,
-            Generator.backend_agent_interface_list,
-            Generator.frontend_class_field_lines,
-            Generator.frontend_constructor_init_list,
-            Generator.frontend_domain_class_lines,
-            Generator.frontend_method_list,
-            Generator.method_handler_list,
-            Generator.method_name_enum_list,
-            Generator.backend_constructor_init_list,
-            Generator.backend_virtual_setters_list,
-            Generator.backend_setters_list,
-            Generator.backend_field_list]
-
         for json_domain in json_api["domains"]:
             domain_name = json_domain["domain"]
             domain_name_lower = domain_name.lower()
 
-            domain_fixes = DomainNameFixes.get_fixed_data(domain_name)
-
-            agent_field_name = domain_fixes.agent_field_name
+            agent_field_name = DomainNameFixes.get_fixed_data(domain_name)
 
             frontend_method_declaration_lines = []
 
             if "events" in json_domain:
                 for json_event in json_domain["events"]:
                     Generator.process_event(json_event, domain_name, frontend_method_declaration_lines)
 
             Generator.frontend_class_field_lines.append("    %s m_%s;\n" % (domain_name, domain_name_lower))
             if Generator.frontend_constructor_init_list:
                 Generator.frontend_constructor_init_list.append("    , ")
@@ skipping 67 matching lines @@
         backend_agent_interface_list = [] if "redirect" in json_command else Generator.backend_agent_interface_list
 
         ad_hoc_type_output = []
         backend_agent_interface_list.append(ad_hoc_type_output)
         ad_hoc_type_writer = Writer(ad_hoc_type_output, "        ")
 
         backend_agent_interface_list.append("        virtual void %s(ErrorString*" % json_command_name)
 
         method_in_code = ""
         method_out_code = ""
-        result_object_declaration = ""
         agent_call_param_list = ["&error"]
         agent_call_params_declaration_list = ["    ErrorString error;"]
         send_response_call_params_list = ["error"]
         request_message_param = ""
         normal_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()
@@ skipping 12 matching lines @@
 
             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()
-                if optional:
-                    type_model = non_optional_type_model.get_optional()
-                else:
-                    type_model = non_optional_type_model
 
                 if optional:
                     code = ("    bool %s_valueFound = false;\n"
                             "    %s in_%s = get%s(paramsContainerPtr, \"%s\", &%s_valueFound, protocolErrors);\n" %
                            (json_param_name, non_optional_type_model.get_command_return_pass_model().get_return_var_type(), json_param_name, getter_name, json_param_name, json_param_name))
                     param = "%s_valueFound ? &in_%s : 0" % (json_param_name, json_param_name)
                     # FIXME: pass optional refptr-values as PassRefPtr
                     formal_param_type_pattern = "const %s*"
                 else:
                     code = ("    %s in_%s = get%s(paramsContainerPtr, \"%s\", 0, protocolErrors);\n" %
@@ skipping 17 matching lines @@
 
             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_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("    " + callback_name + "(PassRefPtrWillBeRawPtr<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"
+            method_out_code += "    RefPtrWillBeRawPtr<" + agent_interface_name + "::" + callback_name + "> callback = adoptRefWillBeNoop(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"
-            backend_agent_interface_list.append(", PassRefPtr<%s> callback" % callback_name)
+            backend_agent_interface_list.append(", PassRefPtrWillBeRawPtr<%s> callback" % callback_name)
         else:
             if "returns" in json_command:
                 method_out_code += "\n"
                 agent_call_params_declaration_list.append("    RefPtr<JSONObject> result = JSONObject::create();")
                 send_response_call_params_list.append("result")
                 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_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():
@@ skipping 18 matching lines @@
                     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
+            agent_field = "m_" + DomainNameFixes.get_fixed_data(json_command.get("redirect"))
 
         Generator.backend_method_implementation_list.append(Templates.backend_method.substitute(None,
             domainName=domain_name, methodName=json_command_name,
             agentField=agent_field,
             methodCode="".join([method_in_code, method_out_code]),
             agentCallParamsDeclaration="\n".join(agent_call_params_declaration_list),
             agentCallParams=", ".join(agent_call_param_list),
             requestMessageObject=request_message_param,
             responseCook=normal_response_cook_text,
             sendResponseCallParams=", ".join(send_response_call_params_list),
@@ skipping 119 matching lines @@
     def process_types(type_map):
         output = Generator.type_builder_fragments
 
         class GenerateContext:
             validator_writer = Writer(Generator.validator_impl_list, "")
             cpp_writer = Writer(Generator.type_builder_impl_list, "")
 
         def generate_all_domains_code(out, type_data_callback):
             writer = Writer(out, "")
             for domain_data in type_map.domains():
-                domain_fixes = DomainNameFixes.get_fixed_data(domain_data.name())
-
                 namespace_declared = []
 
                 def namespace_lazy_generator():
                     if not namespace_declared:
                         writer.newline("namespace ")
                         writer.append(domain_data.name())
                         writer.append(" {\n")
                         # What is a better way to change value from outer scope?
                         namespace_declared.append(True)
                     return writer
@@ skipping 39 matching lines @@
 
     def fill_recursive(l):
         for item in l:
             if isinstance(item, list):
                 fill_recursive(item)
             else:
                 res.append(item)
     fill_recursive(input)
     return res
 
-
-# A writer that only updates file if it actually changed to better support incremental build.
-class SmartOutput:
-    def __init__(self, file_name):
-        self.file_name_ = file_name
-        self.output_ = ""
-
-    def write(self, text):
-        self.output_ += text
-
-    def close(self):
-        text_changed = True
-
-        try:
-            read_file = open(self.file_name_, "r")
-            old_text = read_file.read()
-            read_file.close()
-            text_changed = old_text != self.output_
-        except:
-            # Ignore, just overwrite by default
-            pass
-
-        if text_changed:
-            out_file = open(self.file_name_, "w")
-            out_file.write(self.output_)
-            out_file.close()
-
-
 def output_file(file_name):
-    # For now, disable the incremental build optimisation in all cases.
-    if False:
-        return SmartOutput(file_name)
-    else:
-        return open(file_name, "w")
+    return open(file_name, "w")
 
 
 Generator.go()
 
 backend_h_file = output_file(output_dirname + "/InspectorBackendDispatcher.h")
 backend_cpp_file = output_file(output_dirname + "/InspectorBackendDispatcher.cpp")
 
 frontend_h_file = output_file(output_dirname + "/InspectorFrontend.h")
 frontend_cpp_file = output_file(output_dirname + "/InspectorFrontend.cpp")
 
@@ skipping 36 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()