DevTools: generate string16-based handlers for v8_inspector.

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 string
 import optparse
 import re
 try:
@@ skipping 72 matching lines @@
 
 def patch_full_qualified_refs():
     def patch_full_qualified_refs_in_domain(json, domain_name):
         if isinstance(json, list):
             for item in json:
                 patch_full_qualified_refs_in_domain(item, domain_name)
 
         if not isinstance(json, dict):
             return
         for key in json:
+            if key == "type" and json[key] == "string":
+                json[key] = domain_name + ".string"
             if key != "$ref":
                 patch_full_qualified_refs_in_domain(json[key], domain_name)
                 continue
             if json["$ref"].find(".") == -1:
                 json["$ref"] = domain_name + "." + json["$ref"]
 
     for domain in json_api["domains"]:
         patch_full_qualified_refs_in_domain(domain, domain["domain"])
 
 
@@ skipping 29 matching lines @@
         "pass_type": "PassOwnPtr<protocol::Value>",
         "to_raw_type": "%s.get()",
         "to_pass_type": "%s.release()",
         "type": "OwnPtr<protocol::Value>",
         "raw_type": "protocol::Value",
         "raw_pass_type": "protocol::Value*",
         "raw_return_type": "protocol::Value*",
     }
 
 
+def create_string_type_definition(domain):
+    if domain in ["Runtime", "Debugger", "Profiler", "HeapProfiler"]:

[dgozman, 2016/03/08 01:35:12]

Mark them in protocol.json.

[pfeldman, 2016/03/08 02:24:59]

We'll split them.

+        return {
+            "return_type": "String16",
+            "pass_type": "const String16&",
+            "to_pass_type": "%s",
+            "to_raw_type": "%s",
+            "type": "String16",
+            "raw_type": "String16",
+            "raw_pass_type": "const String16&",
+            "raw_return_type": "String16",
+        }
+    return {
+        "return_type": "String",
+        "pass_type": "const String&",
+        "to_pass_type": "%s",
+        "to_raw_type": "%s",
+        "type": "String",
+        "raw_type": "String",
+        "raw_pass_type": "const String&",
+        "raw_return_type": "String",
+    }
+
+
 def create_primitive_type_definition(type):
-    if type == "string":
-        return {
-            "return_type": "String",
-            "pass_type": "const String&",
-            "to_pass_type": "%s",
-            "to_raw_type": "%s",
-            "type": "String",
-            "raw_type": "String",
-            "raw_pass_type": "const String&",
-            "raw_return_type": "String",
-        }
-
     typedefs = {
         "number": "double",
         "integer": "int",
         "boolean": "bool"
     }
     jsontypes = {
         "number": "TypeNumber",
         "integer": "TypeNumber",
         "boolean": "TypeBoolean",
     }
     return {
         "return_type": typedefs[type],
         "pass_type": typedefs[type],
         "to_pass_type": "%s",
         "to_raw_type": "%s",
         "type": typedefs[type],
         "raw_type": typedefs[type],
         "raw_pass_type": typedefs[type],
         "raw_return_type": typedefs[type],
     }
 
 type_definitions = {}
-type_definitions["string"] = create_primitive_type_definition("string")
 type_definitions["number"] = create_primitive_type_definition("number")
 type_definitions["integer"] = create_primitive_type_definition("integer")
 type_definitions["boolean"] = create_primitive_type_definition("boolean")
 type_definitions["object"] = create_object_type_definition()
 type_definitions["any"] = create_any_type_definition()
 
-
 def wrap_array_definition(type):
     return {
         "return_type": "PassOwnPtr<protocol::Array<%s>>" % type["raw_type"],
         "pass_type": "PassOwnPtr<protocol::Array<%s>>" % type["raw_type"],
         "to_raw_type": "%s.get()",
         "to_pass_type": "%s.release()",
         "type": "OwnPtr<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": "adoptPtr(new protocol::Array<%s>())" % type["raw_type"],
         "out_type": "protocol::Array<%s>&" % type["raw_type"],
     }
 
 
 def create_type_definitions():
     for domain in json_api["domains"]:
+        type_definitions[domain["domain"] + ".string"] = create_string_type_definition(domain["domain"])
         if not ("types" in domain):
             continue
         for type in domain["types"]:
             if type["type"] == "object":
                 type_definitions[domain["domain"] + "." + type["id"]] = create_user_type_definition(domain["domain"], type)
             elif type["type"] == "array":
                 items_type = type["items"]["type"]
                 type_definitions[domain["domain"] + "." + type["id"]] = wrap_array_definition(type_definitions[items_type])
+            elif type["type"] == domain["domain"] + ".string":
+                type_definitions[domain["domain"] + "." + type["id"]] = create_string_type_definition(domain["domain"])
             else:
                 type_definitions[domain["domain"] + "." + type["id"]] = create_primitive_type_definition(type["type"])
 
 patch_full_qualified_refs()
 create_type_definitions()
 
 
 def type_definition(name):
     return type_definitions[name]
 
@@ skipping 29 matching lines @@
     h_file.write(h_template.render(template_context))
     cpp_file.write(cpp_template.render(template_context))
     h_file.close()
     cpp_file.close()
 
 
 jinja_env = initialize_jinja_env(output_dirname)
 generate("Dispatcher")
 generate("Frontend")
 generate("TypeBuilder")