DevTools: migrate from OwnPtr to std::unique_ptr for inspector protocol classes.

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 93 matching lines @@
                 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"])
 
 
 def create_user_type_definition(domain_name, type):
     return {
-        "return_type": "PassOwnPtr<protocol::%s::%s>" % (domain_name, type["id"]),
-        "pass_type": "PassOwnPtr<protocol::%s::%s>" % (domain_name, type["id"]),
+        "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)",
         "to_rvalue": "std::move(%s)",
-        "type": "OwnPtr<protocol::%s::%s>" % (domain_name, type["id"]),
+        "type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
         "raw_type": "protocol::%s::%s" % (domain_name, type["id"]),
         "raw_pass_type": "protocol::%s::%s*" % (domain_name, type["id"]),
         "raw_return_type": "protocol::%s::%s*" % (domain_name, type["id"]),
     }
 
 
 def create_object_type_definition():
     return {
-        "return_type": "PassOwnPtr<protocol::DictionaryValue>",
-        "pass_type": "PassOwnPtr<protocol::DictionaryValue>",
+        "return_type": "std::unique_ptr<protocol::DictionaryValue>",
+        "pass_type": "std::unique_ptr<protocol::DictionaryValue>",
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
         "to_rvalue": "std::move(%s)",
-        "type": "OwnPtr<protocol::DictionaryValue>",
+        "type": "std::unique_ptr<protocol::DictionaryValue>",
         "raw_type": "protocol::DictionaryValue",
         "raw_pass_type": "protocol::DictionaryValue*",
         "raw_return_type": "protocol::DictionaryValue*",
     }
 
 
 def create_any_type_definition():
     return {
-        "return_type": "PassOwnPtr<protocol::Value>",
-        "pass_type": "PassOwnPtr<protocol::Value>",
+        "return_type": "std::unique_ptr<protocol::Value>",
+        "pass_type": "std::unique_ptr<protocol::Value>",
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
         "to_rvalue": "std::move(%s)",
-        "type": "OwnPtr<protocol::Value>",
+        "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(domain):
     if domain in ["Runtime", "Debugger", "Profiler", "HeapProfiler"]:
         return {
             "return_type": "String16",
@@ skipping 44 matching lines @@
 
 type_definitions = {}
 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"],
+        "return_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
+        "pass_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
         "to_raw_type": "%s.get()",
         "to_pass_type": "std::move(%s)",
         "to_rvalue": "std::move(%s)",
-        "type": "OwnPtr<protocol::Array<%s>>" % type["raw_type"],
+        "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": "adoptPtr(new 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():
     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"]:
@@ skipping 70 matching lines @@
     cpp_file.write(cpp_template.render(template_context))
     h_file.close()
     cpp_file.close()
 
 
 jinja_env = initialize_jinja_env(output_dirname)
 generate("Backend")
 generate("Dispatcher")
 generate("Frontend")
 generate("TypeBuilder")