Convert //tools to use std::unique_ptr

tools/json_schema_compiler/cc_generator.py

 # Copyright (c) 2012 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.
 
 from code import Code
 from model import PropertyType
 import cpp_util
 import schema_util
 import util_cc_helper
 from cpp_namespace_environment import CppNamespaceEnvironment
@@ skipping 393 matching lines @@
       'src': src,
       'dst': dst,
       'name': prop.unix_name
     })
     return c
 
   def _GenerateTypeFromValue(self, cpp_namespace, type_):
     classname = cpp_util.Classname(schema_util.StripNamespace(type_.name))
     c = Code()
     (c.Append('// static')
-      .Append('scoped_ptr<%s> %s::FromValue(%s) {' % (classname,
+      .Append('std::unique_ptr<%s> %s::FromValue(%s) {' % (classname,
         cpp_namespace, self._GenerateParams(('const base::Value& value',))))
     )
     if self._generate_error_messages:
       c.Append('DCHECK(error);')
-    (c.Append('  scoped_ptr<%s> out(new %s());' % (classname, classname))
+    (c.Append('  std::unique_ptr<%s> out(new %s());' % (classname, classname))
       .Append('  if (!Populate(%s))' % self._GenerateArgs(
           ('value', 'out.get()')))
-      .Append('    return scoped_ptr<%s>();' % classname)
+      .Append('    return nullptr;')
       .Append('  return out;')
       .Append('}')
     )
     return c
 
   def _GenerateTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes the type into a base::Value.
     E.g. for type "Foo" generates Foo::ToValue()
     """
     if type_.property_type == PropertyType.OBJECT:
       return self._GenerateObjectTypeToValue(cpp_namespace, type_)
     elif type_.property_type == PropertyType.CHOICES:
       return self._GenerateChoiceTypeToValue(cpp_namespace, type_)
     else:
       raise ValueError("Unsupported property type %s" % type_.type_)
 
   def _GenerateObjectTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes an object-representing type
     into a base::DictionaryValue.
     """
     c = Code()
-    (c.Sblock('scoped_ptr<base::DictionaryValue> %s::ToValue() const {' %
+    (c.Sblock('std::unique_ptr<base::DictionaryValue> %s::ToValue() const {' %
           cpp_namespace)
-        .Append('scoped_ptr<base::DictionaryValue> value('
+        .Append('std::unique_ptr<base::DictionaryValue> value('
                     'new base::DictionaryValue());')
         .Append()
     )
 
     for prop in type_.properties.values():
       prop_var = 'this->%s' % prop.unix_name
       if prop.optional:
         underlying_type = self._type_helper.FollowRef(prop.type_)
         if underlying_type.property_type == PropertyType.ENUM:
           # Optional enum values are generated with a NONE enum value,
@@ skipping 36 matching lines @@
 
     return (c.Append()
              .Append('return value;')
            .Eblock('}'))
 
   def _GenerateChoiceTypeToValue(self, cpp_namespace, type_):
     """Generates a function that serializes a choice-representing type
     into a base::Value.
     """
     c = Code()
-    c.Sblock('scoped_ptr<base::Value> %s::ToValue() const {' % cpp_namespace)
-    c.Append('scoped_ptr<base::Value> result;')
+    c.Sblock('std::unique_ptr<base::Value> %s::ToValue() const {' %
+                 cpp_namespace)
+    c.Append('std::unique_ptr<base::Value> result;')
     for choice in type_.choices:
       choice_var = 'as_%s' % choice.unix_name
       # Enums cannot be wrapped with scoped_ptr, but the XXX_NONE enum value
       # is equal to 0.
       (c.Sblock('if (%s) {' % choice_var)
           .Append('DCHECK(!result) << "Cannot set multiple choices for %s";' %
                       type_.unix_name)
           .Cblock(self._CreateValueFromType('result.reset(%s);',
                                             choice.name,
                                             choice,
@@ skipping 157 matching lines @@
     if num_required == len(function.params):
       c.Sblock('if (%(var)s.GetSize() != %(total)d) {')
     elif not num_required:
       c.Sblock('if (%(var)s.GetSize() > %(total)d) {')
     else:
       c.Sblock('if (%(var)s.GetSize() < %(required)d'
           ' || %(var)s.GetSize() > %(total)d) {')
     (c.Concat(self._GenerateError(
         '"expected %%(total)d arguments, got " '
         '+ base::IntToString(%%(var)s.GetSize())'))
-      .Append('return scoped_ptr<Params>();')
+      .Append('return nullptr;')
       .Eblock('}')
       .Substitute({
         'var': var,
         'required': num_required,
         'total': len(function.params),
     }))
     return c
 
   def _GenerateFunctionParamsCreate(self, function):
     """Generate function to create an instance of Params. The generated
     function takes a base::ListValue of arguments.
 
     E.g for function "Bar", generate Bar::Params::Create()
     """
     c = Code()
     (c.Append('// static')
-      .Sblock('scoped_ptr<Params> Params::Create(%s) {' % self._GenerateParams(
-        ['const base::ListValue& args']))
+      .Sblock('std::unique_ptr<Params> Params::Create(%s) {' %
+                  self._GenerateParams(['const base::ListValue& args']))
     )
     if self._generate_error_messages:
       c.Append('DCHECK(error);')
     (c.Concat(self._GenerateParamsCheck(function, 'args'))
-      .Append('scoped_ptr<Params> params(new Params());')
+      .Append('std::unique_ptr<Params> params(new Params());')
     )
 
     for param in function.params:
       c.Concat(self._InitializePropertyToDefault(param, 'params'))
 
     for i, param in enumerate(function.params):
       # Any failure will cause this function to return. If any argument is
       # incorrect or missing, those following it are not processed. Note that
       # for optional arguments, we allow missing arguments and proceed because
       # there may be other arguments following it.
-      failure_value = 'scoped_ptr<Params>()'
+      failure_value = 'std::unique_ptr<Params>()'
       c.Append()
       value_var = param.unix_name + '_value'
       (c.Append('const base::Value* %(value_var)s = NULL;')
         .Append('if (args.Get(%(i)s, &%(value_var)s) &&')
         .Sblock('    !%(value_var)s->IsType(base::Value::TYPE_NULL)) {')
         .Concat(self._GeneratePopulatePropertyFromValue(
             param, value_var, 'params', failure_value))
         .Eblock('}')
       )
       if not param.optional:
@@ skipping 78 matching lines @@
           .Concat(self._GenerateError(
             '"\'%%(key)s\': expected dictionary, got " + ' +
             self._util_cc_helper.GetValueTypeString('%%(src_var)s', True))))
         # If an optional property fails to populate, the population can still
         # succeed with a warning. If no error messages are generated, this
         # warning is not set and we fail out instead.
         if not self._generate_error_messages:
           c.Append('return %(failure_value)s;')
         (c.Eblock('}')
           .Sblock('else {')
-          .Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
+          .Append('std::unique_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
           .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
             ('*dictionary', 'temp.get()')))
           .Append('  return %(failure_value)s;')
         )
         (c.Append('}')
           .Append('else')
          .Append('  %(dst_var)s = std::move(temp);')
           .Eblock('}')
         )
       else:
@@ skipping 43 matching lines @@
         c.Concat(self._GenerateError(
             '"unable to populate array \'%%(parent_key)s\'"'))
         if is_ptr and self._generate_error_messages:
           c.Append('%(dst_var)s.reset();')
         else:
           c.Append('return %(failure_value)s;')
         c.Eblock('}')
       c.Eblock('}')
     elif underlying_type.property_type == PropertyType.CHOICES:
       if is_ptr:
-        (c.Append('scoped_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
+        (c.Append('std::unique_ptr<%(cpp_type)s> temp(new %(cpp_type)s());')
           .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
             ('*%(src_var)s', 'temp.get()')))
           .Append('  return %(failure_value)s;')
           .Append('%(dst_var)s = std::move(temp);')
         )
       else:
         (c.Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
             ('*%(src_var)s', '&%(dst_var)s')))
           .Append('  return %(failure_value)s;'))
     elif underlying_type.property_type == PropertyType.ENUM:
@@ skipping 188 matching lines @@
     E.g for event "Baz", generate Baz::Create
 
     function_scope: the function scope path, e.g. Foo::Bar for the function
                     Foo::Bar::Baz(). May be None if there is no function scope.
     callback: the Function object we are creating callback arguments for.
     """
     c = Code()
     params = callback.params
     c.Concat(self._GeneratePropertyFunctions(function_scope, params))
 
-    (c.Sblock('scoped_ptr<base::ListValue> %(function_scope)s'
+    (c.Sblock('std::unique_ptr<base::ListValue> %(function_scope)s'
                   'Create(%(declaration_list)s) {')
-      .Append('scoped_ptr<base::ListValue> create_results('
+      .Append('std::unique_ptr<base::ListValue> create_results('
               'new base::ListValue());')
     )
     declaration_list = []
     for param in params:
       declaration_list.append(cpp_util.GetParameterDeclaration(
           param, self._type_helper.GetCppType(param.type_)))
       c.Cblock(self._CreateValueFromType('create_results->Append(%s);',
                                          param.name,
                                          param.type_,
                                          param.unix_name))
@@ skipping 54 matching lines @@
     if self._generate_error_messages:
       params = list(params) + ['base::string16* error']
     return ', '.join(str(p) for p in params)
 
   def _GenerateArgs(self, args):
     """Builds the argument list for a function, given an array of arguments.
     """
     if self._generate_error_messages:
       args = list(args) + ['error']
     return ', '.join(str(a) for a in args)