Convert Pass()→std::move() in generated JS schema bindings.

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 30 matching lines @@
       .Append()
       .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file)
       .Append()
       .Append(self._util_cc_helper.GetIncludePath())
       .Append('#include "base/logging.h"')
       .Append('#include "base/strings/string_number_conversions.h"')
       .Append('#include "base/strings/utf_string_conversions.h"')
       .Append('#include "%s/%s.h"' %
               (self._namespace.source_file_dir, self._namespace.short_filename))
       .Append('#include <set>')
+      .Append('#include <utility>')
       .Cblock(self._type_helper.GenerateIncludes(include_soft=True))
       .Append()
       .Append('using base::UTF8ToUTF16;')
       .Append()
       .Concat(cpp_util.OpenNamespace(cpp_namespace))
     )
     if self._namespace.properties:
       (c.Append('//')
         .Append('// Properties')
         .Append('//')
@@ skipping 263 matching lines @@
     (c.Append('// static')
       .Append('scoped_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))
       .Append('  if (!Populate(%s))' % self._GenerateArgs(
           ('value', 'out.get()')))
       .Append('    return scoped_ptr<%s>();' % classname)
-      .Append('  return out.Pass();')
+      .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_)
@@ skipping 55 matching lines @@
         (c.Sblock('for (const auto& it : additional_properties) {')
           .Cblock(self._CreateValueFromType(
               'value->SetWithoutPathExpansion(it.first, %s);',
               type_.additional_properties.name,
               type_.additional_properties,
               '%sit.second' % ('*' if needs_unwrap else '')))
           .Eblock('}')
         )
 
     return (c.Append()
-             .Append('return value.Pass();')
+             .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;')
     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,
                                             choice_var,
                                             True))
         .Eblock('}')
       )
     (c.Append('DCHECK(result) << "Must set at least one choice for %s";' %
                   type_.unix_name)
-      .Append('return result.Pass();')
+      .Append('return result;')
       .Eblock('}')
     )
     return c
 
   def _GenerateFunction(self, function):
     """Generates the definitions for function structs.
     """
     c = Code()
 
     # TODO(kalman): use function.unix_name not Classname.
@@ skipping 191 matching lines @@
             param, value_var, 'params', failure_value))
         .Eblock('}')
       )
       if not param.optional:
         (c.Sblock('else {')
           .Concat(self._GenerateError('"\'%%(key)s\' is required"'))
           .Append('return %s;' % failure_value)
           .Eblock('}'))
       c.Substitute({'value_var': value_var, 'i': i, 'key': param.name})
     (c.Append()
-      .Append('return params.Pass();')
+      .Append('return params;')
       .Eblock('}')
       .Append()
     )
 
     return c
 
   def _GeneratePopulatePropertyFromValue(self,
                                          prop,
                                          src_var,
                                          dst_class_var,
@@ skipping 68 matching lines @@
           c.Append('return %(failure_value)s;')
         (c.Eblock('}')
           .Sblock('else {')
           .Append('scoped_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 = temp.Pass();')
+         .Append('  %(dst_var)s = std::move(temp);')
           .Eblock('}')
         )
       else:
         (c.Append('const base::DictionaryValue* dictionary = NULL;')
           .Sblock('if (!%(src_var)s->GetAsDictionary(&dictionary)) {')
           .Concat(self._GenerateError(
             '"\'%%(key)s\': expected dictionary, got " + ' +
             self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
           .Append('return %(failure_value)s;')
           .Eblock('}')
@@ skipping 40 matching lines @@
         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());')
           .Append('if (!%%(cpp_type)s::Populate(%s))' % self._GenerateArgs(
             ('*%(src_var)s', 'temp.get()')))
           .Append('  return %(failure_value)s;')
-          .Append('%(dst_var)s = temp.Pass();')
+          .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:
       c.Concat(self._GenerateStringToEnumConversion(underlying_type,
                                                     src_var,
                                                     dst_var,
                                                     failure_value))
@@ skipping 197 matching lines @@
               '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))
-    c.Append('return create_results.Pass();')
+    c.Append('return create_results;')
     c.Eblock('}')
     c.Substitute({
         'function_scope': ('%s::' % function_scope) if function_scope else '',
         'declaration_list': ', '.join(declaration_list),
         'param_names': ', '.join(param.unix_name for param in params)
     })
     return c
 
   def _GenerateEventNameConstant(self, event):
     """Generates a constant string array for the event name.
@@ skipping 43 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)