Convert //tools to use std::unique_ptr

tools/json_schema_compiler/h_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.
 
 import os
 
 from code import Code
 from model import PropertyType
 import cpp_util
 import schema_util
@@ skipping 35 matching lines @@
     # other cases, generate soft dependencies so that they can include
     # non-optional types from other namespaces.
     include_soft = self._namespace.name not in ('tabs', 'windows')
 
     (c.Append('#ifndef %s' % ifndef_name)
       .Append('#define %s' % ifndef_name)
       .Append()
       .Append('#include <stdint.h>')
       .Append()
       .Append('#include <map>')
+      .Append('#include <memory>')
       .Append('#include <string>')
       .Append('#include <vector>')
       .Append()
       .Append('#include "base/logging.h"')
-      .Append('#include "base/memory/scoped_ptr.h"')
       .Append('#include "base/values.h"')
       .Cblock(self._type_helper.GenerateIncludes(include_soft=include_soft))
       .Append()
     )
 
     # Hack: we're not generating soft includes for tabs and windows, so we need
     # to generate forward declarations for them.
     if not include_soft:
       c.Cblock(self._type_helper.GenerateForwardDeclarations())
 
@@ skipping 163 matching lines @@
         (c.Append()
           .Comment('Populates a %s object from a base::Value. Returns'
                    ' whether |out| was successfully populated.' % classname)
           .Append('static bool Populate(%s);' % self._GenerateParams(
               ('const base::Value& value', '%s* out' % classname)))
         )
         if is_toplevel:
           (c.Append()
             .Comment('Creates a %s object from a base::Value, or NULL on '
                      'failure.' % classname)
-            .Append('static scoped_ptr<%s> FromValue(%s);' % (
+            .Append('static std::unique_ptr<%s> FromValue(%s);' % (
                 classname, self._GenerateParams(('const base::Value& value',))))
           )
       if type_.origin.from_client:
         value_type = ('base::Value'
                       if type_.property_type is PropertyType.CHOICES else
                       'base::DictionaryValue')
         (c.Append()
           .Comment('Returns a new %s representing the serialized form of this '
                    '%s object.' % (value_type, classname))
-          .Append('scoped_ptr<%s> ToValue() const;' % value_type)
+          .Append('std::unique_ptr<%s> ToValue() const;' % value_type)
         )
       if type_.property_type == PropertyType.CHOICES:
         # Choices are modelled with optional fields for each choice. Exactly one
         # field of the choice is guaranteed to be set by the compiler.
         c.Cblock(self._GenerateTypes(type_.choices))
         c.Append('// Choices:')
         for choice_type in type_.choices:
           c.Append('%s as_%s;' % (
               self._type_helper.GetCppType(choice_type, is_ptr=True),
               choice_type.unix_name))
@@ skipping 56 matching lines @@
     return c
 
   def _GenerateFunctionParams(self, function):
     """Generates the struct for passing parameters from JSON to a function.
     """
     if not function.params:
       return Code()
 
     c = Code()
     (c.Sblock('struct Params {')
-      .Append('static scoped_ptr<Params> Create(%s);' % self._GenerateParams(
-          ('const base::ListValue& args',)))
+      .Append('static std::unique_ptr<Params> Create(%s);' %
+                  self._GenerateParams(('const base::ListValue& args',)))
       .Append('~Params();')
       .Append()
       .Cblock(self._GenerateTypes(p.type_ for p in function.params))
       .Cblock(self._GenerateFields(function.params))
       .Eblock()
       .Append()
       .Sblock(' private:')
         .Append('Params();')
         .Append()
         .Append('DISALLOW_COPY_AND_ASSIGN(Params);')
@@ skipping 18 matching lines @@
     c = Code()
     params = function.params
     c.Cblock(self._GenerateTypes((p.type_ for p in params), is_toplevel=True))
 
     declaration_list = []
     for param in params:
       if param.description:
         c.Comment(param.description)
       declaration_list.append(cpp_util.GetParameterDeclaration(
           param, self._type_helper.GetCppType(param.type_)))
-    c.Append('scoped_ptr<base::ListValue> Create(%s);' %
+    c.Append('std::unique_ptr<base::ListValue> Create(%s);' %
              ', '.join(declaration_list))
     return c
 
   def _GenerateEventNameConstant(self, event):
     """Generates a constant string array for the event name.
     """
     c = Code()
     c.Append('extern const char kEventName[];  // "%s.%s"' % (
                  self._namespace.name, event.name))
     c.Append()
@@ skipping 14 matching lines @@
     """Builds the parameter list for a function, given an array of parameters.
     """
     # |error| is populated with warnings and/or errors found during parsing.
     # |error| being set does not necessarily imply failure and may be
     # recoverable.
     # For example, optional properties may have failed to parse, but the
     # parser was able to continue.
     if self._generate_error_messages:
       params += ('base::string16* error',)
     return ', '.join(str(p) for p in params)