[DevTools] Generate separate copies of inspector_protocol.

third_party/WebKit/Source/platform/inspector_protocol/CodeGenerator.py

 # Copyright 2016 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 os.path
 import sys
 import optparse
 import collections
 import functools
 try:
@@ skipping 146 matching lines @@
                 has_exports = calculate_exports_in_json(json_value[key]) or has_exports
         return has_exports
 
     protocol.json_api["has_exports"] = False
     for domain_json in protocol.json_api["domains"]:
         domain_json["has_exports"] = calculate_exports_in_json(domain_json)
         if domain_json["has_exports"] and domain_json["domain"] in protocol.generate_domains:
             protocol.json_api["has_exports"] = True
 
 
-def create_imported_type_definition(domain_name, type):
+def create_imported_type_definition(domain_name, type, imported_namespace):
     # pylint: disable=W0622
     return {
-        "return_type": "std::unique_ptr<protocol::%s::API::%s>" % (domain_name, type["id"]),
-        "pass_type": "std::unique_ptr<protocol::%s::API::%s>" % (domain_name, type["id"]),
+        "return_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
+        "pass_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
         "to_rvalue": "std::move(%s)",
-        "type": "std::unique_ptr<protocol::%s::API::%s>" % (domain_name, type["id"]),
-        "raw_type": "protocol::%s::API::%s" % (domain_name, type["id"]),
-        "raw_pass_type": "protocol::%s::API::%s*" % (domain_name, type["id"]),
-        "raw_return_type": "protocol::%s::API::%s*" % (domain_name, type["id"]),
+        "type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
+        "raw_type": "%s::%s::API::%s" % (imported_namespace, domain_name, type["id"]),
+        "raw_pass_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type["id"]),
+        "raw_return_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type["id"]),
     }
 
 
 def create_user_type_definition(domain_name, type):
     # pylint: disable=W0622
     return {
         "return_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
         "pass_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
@@ skipping 28 matching lines @@
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
         "to_rvalue": "std::move(%s)",
         "type": "std::unique_ptr<protocol::Value>",
         "raw_type": "protocol::Value",
         "raw_pass_type": "protocol::Value*",
         "raw_return_type": "protocol::Value*",
     }
 
 
-def create_string_type_definition(string_type):
+def create_string_type_definition():
     # pylint: disable=W0622
     return {
-        "return_type": string_type,
-        "pass_type": ("const %s&" % string_type),
+        "return_type": "String",
+        "pass_type": "const String&",
         "to_pass_type": "%s",
         "to_raw_type": "%s",
         "to_rvalue": "%s",
-        "type": string_type,
-        "raw_type": string_type,
-        "raw_pass_type": ("const %s&" % string_type),
-        "raw_return_type": string_type,
+        "type": "String",
+        "raw_type": "String",
+        "raw_pass_type": "const String&",
+        "raw_return_type": "String",
     }
 
 
 def create_primitive_type_definition(type):
     # pylint: disable=W0622
     typedefs = {
         "number": "double",
         "integer": "int",
         "boolean": "bool"
     }
@@ skipping 31 matching lines @@
         "to_rvalue": "std::move(%s)",
         "type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
         "raw_type": "protocol::Array<%s>" % type["raw_type"],
         "raw_pass_type": "protocol::Array<%s>*" % type["raw_type"],
         "raw_return_type": "protocol::Array<%s>*" % type["raw_type"],
         "create_type": "wrapUnique(new protocol::Array<%s>())" % type["raw_type"],
         "out_type": "protocol::Array<%s>&" % type["raw_type"],
     }
 
 
-def create_type_definitions(protocol, string_type):
+def create_type_definitions(protocol, imported_namespace):
     protocol.type_definitions = {}
     protocol.type_definitions["number"] = create_primitive_type_definition("number")
     protocol.type_definitions["integer"] = create_primitive_type_definition("integer")
     protocol.type_definitions["boolean"] = create_primitive_type_definition("boolean")
     protocol.type_definitions["object"] = create_object_type_definition()
     protocol.type_definitions["any"] = create_any_type_definition()
     for domain in protocol.json_api["domains"]:
-        protocol.type_definitions[domain["domain"] + ".string"] = create_string_type_definition(string_type)
+        protocol.type_definitions[domain["domain"] + ".string"] = create_string_type_definition()
         if not ("types" in domain):
             continue
         for type in domain["types"]:
             type_name = domain["domain"] + "." + type["id"]
             if type["type"] == "object" and domain["domain"] in protocol.imported_domains:
-                protocol.type_definitions[type_name] = create_imported_type_definition(domain["domain"], type)
+                protocol.type_definitions[type_name] = create_imported_type_definition(domain["domain"], type, imported_namespace)
             elif type["type"] == "object":
                 protocol.type_definitions[type_name] = create_user_type_definition(domain["domain"], type)
             elif type["type"] == "array":
                 items_type = type["items"]["type"]
                 protocol.type_definitions[type_name] = wrap_array_definition(protocol.type_definitions[items_type])
             elif type["type"] == domain["domain"] + ".string":
-                protocol.type_definitions[type_name] = create_string_type_definition(string_type)
+                protocol.type_definitions[type_name] = create_string_type_definition()
             else:
                 protocol.type_definitions[type_name] = create_primitive_type_definition(type["type"])
 
 
 def type_definition(protocol, name):
     return protocol.type_definitions[name]
 
 
 def resolve_type(protocol, prop):
     if "$ref" in prop:
@@ skipping 39 matching lines @@
 
 def main():
     config_file, config = read_config()
 
     protocol = Protocol()
     protocol.json_api = {"domains": []}
     protocol.generate_domains = read_protocol_file(config.protocol.path, protocol.json_api)
     protocol.imported_domains = read_protocol_file(config.imported.path, protocol.json_api) if config.imported else []
     patch_full_qualified_refs(protocol)
     calculate_exports(protocol)
-    create_type_definitions(protocol, config.string.class_name)
+    create_type_definitions(protocol, "::".join(config.imported.namespace) if config.imported else "")
 
     if not config.exported:
         for domain_json in protocol.json_api["domains"]:
             if domain_json["has_exports"] and domain_json["domain"] in protocol.generate_domains:
                 sys.stderr.write("Domain %s is exported, but config is missing export entry\n\n" % domain_json["domain"])
                 exit(1)
 
     if not os.path.exists(config.protocol.output):
         os.mkdir(config.protocol.output)
     if protocol.json_api["has_exports"] and not os.path.exists(config.exported.output):
@@ skipping 41 matching lines @@
         template_context = {
             "config": config
         }
 
         # Note these should be sorted in the right order.
         # TODO(dgozman): sort them programmatically based on commented includes.
         lib_h_templates = [
             "Allocator_h.template",
             "Platform_h.template",
             "Collections_h.template",
-            "String16_h.template",
             "ErrorSupport_h.template",
             "Values_h.template",
             "Object_h.template",
             "ValueConversions_h.template",
             "Maybe_h.template",
             "Array_h.template",
             "FrontendChannel_h.template",
             "BackendCallback_h.template",
             "DispatcherBase_h.template",
             "Parser_h.template",
         ]
 
         lib_cpp_templates = [
             "InspectorProtocol_cpp.template",
-            "String16_cpp.template",
             "ErrorSupport_cpp.template",
             "Values_cpp.template",
             "Object_cpp.template",
             "DispatcherBase_cpp.template",
             "Parser_cpp.template",
         ]
 
         def generate_lib_file(file_name, template_files):
             parts = []
             for template_file in template_files:
@@ skipping 15 matching lines @@
     if up_to_date:
         sys.exit()
 
     for file_name, content in outputs.iteritems():
         out_file = open(file_name, "w")
         out_file.write(content)
         out_file.close()
 
 
 main()