Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/devtools/protocol/devtools_protocol_handler_generator.py

 #!/usr/bin/env python
 # Copyright 2014 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 sys
 import string
 import json
 
 blink_protocol_path = sys.argv[1]
@@ skipping 13 matching lines @@
 //  content/browser/devtools/browser_protocol.json
 """
 
 template_h = string.Template(header + """\
 
 #ifndef CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
 #define CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "content/browser/devtools/protocol/devtools_protocol_client.h"
 
 namespace content {
 
 class DevToolsProtocolDispatcher;
 
 namespace devtools {
 
 extern const char kProtocolVersion[];
 
 bool IsSupportedProtocolVersion(const std::string& version);
 
 template<typename T>
 base::Value* CreateValue(const T& param) {
   return new base::FundamentalValue(param);
 }
 
 template<class T>
-base::Value* CreateValue(scoped_ptr<T>& param) {
+base::Value* CreateValue(std::unique_ptr<T>& param) {
   return param.release();
 }
 
 template<class T>
 base::Value* CreateValue(scoped_refptr<T> param) {
   return param->ToValue().release();
 }
 
 template<typename T>
 base::Value* CreateValue(const std::vector<T> param) {
   base::ListValue* result = new base::ListValue();
   for (auto& item : param) {
     result->Append(CreateValue(item));
   }
   return result;
 }
 
 template<>
 base::Value* CreateValue(const std::string& param);
 
 ${types}\
 
 }  // namespace devtools
 
 class DevToolsProtocolDispatcher {
  public:
   using CommandHandler =
       base::Callback<bool(DevToolsCommandId,
-                          scoped_ptr<base::DictionaryValue>)>;
+                          std::unique_ptr<base::DictionaryValue>)>;
 
   explicit DevToolsProtocolDispatcher(DevToolsProtocolDelegate* notifier);
   ~DevToolsProtocolDispatcher();
 
   CommandHandler FindCommandHandler(const std::string& method);
 
 ${setters}\
 
  private:
   using Response = DevToolsProtocolClient::Response;
@@ skipping 28 matching lines @@
     kAllSet = 0,
 ${fields_enum}\
   };
 
 ${methods}\
 
   static scoped_refptr<${declared_name}Builder<kNoneSet>> Create() {
     return new ${declared_name}Builder<kNoneSet>();
   }
 
-  scoped_ptr<base::DictionaryValue> ToValue() {
+  std::unique_ptr<base::DictionaryValue> ToValue() {
     static_assert(MASK == kAllSet, "required properties missing");
-    return make_scoped_ptr(dict_->DeepCopy());
+    return base::WrapUnique(dict_->DeepCopy());
   }
 
  private:
   friend struct ${declared_name}Builder<0>;
   friend class base::RefCounted<${declared_name}Builder<MASK>>;
   ~${declared_name}Builder() {}
 
   ${declared_name}Builder() : dict_(new base::DictionaryValue()) {
   }
 
   template<class T> T* ThisAs() {
     static_assert(sizeof(*this) == sizeof(T), "cannot cast");
     return reinterpret_cast<T*>(this);
   }
 
-  scoped_ptr<base::DictionaryValue> dict_;
+  std::unique_ptr<base::DictionaryValue> dict_;
 };
 
 typedef ${declared_name}Builder<0> ${declared_name};
 
 }  // namespace ${domain}
 """)
 
 tmpl_builder_setter_req = string.Template("""\
   scoped_refptr<${declared_name}Builder<MASK & ~k${Param}>>
   set_${param}(${pass_type} ${param}) {
@@ skipping 71 matching lines @@
 """)
 
 tmpl_setter = string.Template("""\
   void Set${Domain}Handler(
       devtools::${domain}::${Domain}Handler* ${domain}_handler);
 """)
 
 tmpl_callback = string.Template("""\
   bool On${Domain}${Command}(
       DevToolsCommandId command_id,
-      scoped_ptr<base::DictionaryValue> params);
+      std::unique_ptr<base::DictionaryValue> params);
 """)
 
 tmpl_field = string.Template("""\
   devtools::${domain}::${Domain}Handler* ${domain}_handler_;
 """)
 
 template_cc = string.Template(header + """\
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 61 matching lines @@
 """)
 
 tmpl_register = string.Template("""\
   command_handlers_["${Domain}.${command}"] =
       base::Bind(
           &DevToolsProtocolDispatcher::On${TargetDomain}${Command},
           base::Unretained(this));
 """)
 
 tmpl_init_client = string.Template("""\
-  ${domain}_handler_->SetClient(make_scoped_ptr(
+  ${domain}_handler_->SetClient(base::WrapUnique(
       new devtools::${domain}::Client(notifier_)));
 """)
 
 tmpl_callback_impl = string.Template("""\
 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
     DevToolsCommandId command_id,
-    scoped_ptr<base::DictionaryValue> params) {
+    std::unique_ptr<base::DictionaryValue> params) {
 ${prep}\
   Response response = ${domain}_handler_->${Command}(${args});
-  scoped_ptr<base::DictionaryValue> protocol_response;
+  std::unique_ptr<base::DictionaryValue> protocol_response;
   if (client_.SendError(command_id, response))
     return true;
   if (response.IsFallThrough())
     return false;
-  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 ${wrap}\
   client_.SendSuccess(command_id, std::move(result));
   return true;
 }
 """)
 
 tmpl_wrap = string.Template("""\
   result->Set("${proto_param}", devtools::CreateValue(out_${param}));
 """)
 
 tmpl_callback_async_impl = string.Template("""\
 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
     DevToolsCommandId command_id,
-    scoped_ptr<base::DictionaryValue> params) {
+    std::unique_ptr<base::DictionaryValue> params) {
 ${prep}\
   Response response = ${domain}_handler_->${Command}(${args});
   if (client_.SendError(command_id, response))
     return true;
   return !response.IsFallThrough();
 }
 """)
 
 tmpl_prep_req = string.Template("""\
   ${raw_type} in_${param}${init};
@@ skipping 33 matching lines @@
 """)
 
 tmpl_arg_name = string.Template("in_${param}")
 
 tmpl_arg_req = string.Template("${param_pass}")
 
 tmpl_arg_opt = string.Template(
     "${param}_found ? ${param_pass} : nullptr")
 
 tmpl_object_pass = string.Template(
-    "make_scoped_ptr<base::DictionaryValue>(${name}->DeepCopy())")
+    "base::WrapUnique<base::DictionaryValue>(${name}->DeepCopy())")
 
 tmpl_client_impl = string.Template("""\
 namespace ${domain} {
 
 Client::Client(DevToolsProtocolDelegate* notifier)
     : DevToolsProtocolClient(notifier) {
 }
 
 Client::~Client() {
 }
@@ skipping 142 matching lines @@
   mapping["prep_req"] = tmpl_prep_req_list.substitute(mapping,
       item_type = items_map["storage_type"],
       item_init = items_map["init"],
       item_raw_type = items_map["raw_type"],
       item_pass = items_map["pass_template"].substitute(name="item", opt=""),
       ItemType = items_map["Type"])
   mapping["arg_out"] = "&out_%s" % mapping["param"]
 
 def ResolveObject(json, mapping):
   mapping["Type"] = "Dictionary"
-  mapping["storage_type"] = "scoped_ptr<base::DictionaryValue>"
+  mapping["storage_type"] = "std::unique_ptr<base::DictionaryValue>"
   mapping["raw_type"] = "base::DictionaryValue*"
   mapping["pass_template"] = tmpl_object_pass
   mapping["init"] = " = nullptr"
   if "properties" in json:
     if not "declared_name" in mapping:
       mapping["declared_name"] = ("%s%s" %
           (mapping["Command"], Capitalize(mapping["proto_param"])))
       mapping["param_type"] = ("scoped_refptr<%s>" %
           tmpl_typename.substitute(mapping))
       DeclareStruct(json["properties"], mapping)
     else:
       mapping["param_type"] = ("scoped_refptr<%s>" %
           tmpl_typename.substitute(mapping))
     mapping["pass_type"] = mapping["param_type"]
     mapping["arg_out"] = "&out_%s" % mapping["param"]
   else:
     mapping["param_type"] = "base::DictionaryValue"
-    mapping["pass_type"] = "scoped_ptr<base::DictionaryValue>"
+    mapping["pass_type"] = "std::unique_ptr<base::DictionaryValue>"
     mapping["arg_out"] = "out_%s.get()" % mapping["param"]
   mapping["prep_req"] = tmpl_prep_req.substitute(mapping)
 
 def ResolvePrimitive(json, mapping):
   jsonrpc_type = json["type"]
   if jsonrpc_type == "boolean":
     mapping["param_type"] = "bool"
     mapping["Type"] = "Boolean"
     mapping["init"] = " = false"
   elif jsonrpc_type == "integer":
@@ skipping 200 matching lines @@
 output_h_file.close()
 
 output_cc_file.write(template_cc.substitute({},
     major = blink_protocol["version"]["major"],
     minor = blink_protocol["version"]["minor"],
     includes = "".join(sorted(includes)),
     fields_init = ",\n      ".join(fields_init),
     methods = "\n".join(handler_method_impls),
     types = "\n".join(type_impls)))
 output_cc_file.close()