Convert generated extension bindings to use base::Value::CreateDeepCopy

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 25 matching lines @@
         self._namespace.environment.namespace_pattern,
         self._namespace.unix_name)
 
     c = Code()
     (c.Append(cpp_util.CHROMIUM_LICENSE)
       .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/memory/ptr_util.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()
@@ skipping 254 matching lines @@
         .Concat(self._GenerateError(
           '"expected dictionary, got " + ' +
           self._util_cc_helper.GetValueTypeString('value')))
         .Append('return false;')
         .Eblock('}'))
 
       if type_.properties or type_.additional_properties is not None:
         c.Append('const base::DictionaryValue* dict = '
                      'static_cast<const base::DictionaryValue*>(&value);')
         if self._generate_error_messages:
-            c.Append('std::set<std::string> keys;')
+          c.Append('std::set<std::string> keys;')
       for prop in type_.properties.itervalues():
         c.Concat(self._InitializePropertyToDefault(prop, 'out'))
       for prop in type_.properties.itervalues():
         if self._generate_error_messages:
           c.Append('keys.insert("%s");' % (prop.name))
         c.Concat(self._GenerateTypePopulateProperty(prop, 'dict', 'out'))
       # Check for extra values.
       if self._generate_error_messages:
         (c.Sblock('for (base::DictionaryValue::Iterator it(*dict); '
                        '!it.IsAtEnd(); it.Advance()) {')
@@ skipping 172 matching lines @@
     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,
-                                            choice_var,
-                                            True))
+       .Cblock(self._CreateValueFromType('result = %s;',

[Devlin, 2016/04/27 22:33:21]

.Append indentation is off now?

[dcheng, 2016/04/27 22:43:34]

Ran it through the google3 formatter. I hope the result is acceptable.

+                                         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;')
       .Eblock('}')
     )
     return c
 
   def _GenerateFunction(self, function):
@@ skipping 35 matching lines @@
     (c.Append('namespace %s {' % event_namespace)
       .Append()
       .Cblock(self._GenerateEventNameConstant(event))
       .Cblock(self._GenerateCreateCallbackArguments(None, event))
       .Append('}  // namespace %s' % event_namespace)
     )
     return c
 
   def _CreateValueFromType(self, code, prop_name, type_, var, is_ptr=False):
     """Creates a base::Value given a type. Generated code passes ownership
-    to caller.
+    to caller via std::unique_ptr.
 
     var: variable or variable*
 
     E.g for std::string, generate new base::StringValue(var)
     """
     c = Code()
     underlying_type = self._type_helper.FollowRef(type_)
     if underlying_type.property_type == PropertyType.ARRAY:
       # Enums are treated specially because C++ templating thinks that they're
       # ints, but really they're strings. So we create a vector of strings and
@@ skipping 33 matching lines @@
     """Generates the statement to create a base::Value given a type.
 
     type_:  The type of the values being converted.
     var:    The name of the variable.
     is_ptr: Whether |type_| is optional.
     """
     underlying_type = self._type_helper.FollowRef(type_)
     if (underlying_type.property_type == PropertyType.CHOICES or
         underlying_type.property_type == PropertyType.OBJECT):
       if is_ptr:
-        return '(%s)->ToValue().release()' % var
+        return '(%s)->ToValue()' % var
       else:
-        return '(%s).ToValue().release()' % var
+        return '(%s).ToValue()' % var
     elif (underlying_type.property_type == PropertyType.ANY or
           underlying_type.property_type == PropertyType.FUNCTION):
       if is_ptr:
         vardot = '(%s)->' % var
       else:
         vardot = '(%s).' % var
-      return '%sDeepCopy()' % vardot
+      return '%sCreateDeepCopy()' % vardot
     elif underlying_type.property_type == PropertyType.ENUM:
       maybe_namespace = ''
       if type_.property_type == PropertyType.REF:
         maybe_namespace = '%s::' % underlying_type.namespace.unix_name
-      return 'new base::StringValue(%sToString(%s))' % (maybe_namespace, var)
+      return 'base::WrapUnique(new base::StringValue(%sToString(%s)))' % (
+          maybe_namespace, var)
     elif underlying_type.property_type == PropertyType.BINARY:
       if is_ptr:
         vardot = var + '->'
       else:
         vardot = var + '.'
       return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(),'
               ' %ssize())' % (vardot, vardot))
     elif underlying_type.property_type == PropertyType.ARRAY:
-      return '%s.release()' % self._util_cc_helper.CreateValueFromArray(
+      return '%s' % self._util_cc_helper.CreateValueFromArray(
           var,
           is_ptr)
     elif underlying_type.property_type.is_fundamental:
       if is_ptr:
         var = '*%s' % var
       if underlying_type.property_type == PropertyType.STRING:
-        return 'new base::StringValue(%s)' % var
+        return 'base::WrapUnique(new base::StringValue(%s))' % var
       else:
-        return 'new base::FundamentalValue(%s)' % var
+        return 'base::WrapUnique(new base::FundamentalValue(%s))' % var
     else:
       raise NotImplementedError('Conversion of %s to base::Value not '
                                 'implemented' % repr(type_.type_))
 
   def _GenerateParamsCheck(self, function, var):
     """Generates a check for the correct number of arguments when creating
     Params.
     """
     c = Code()
     num_required = 0
@@ skipping 163 matching lines @@
           .Eblock('}')
           .Append('if (!%%(cpp_type)s::Populate(%s)) {' % self._GenerateArgs(
             ('*dictionary', '&%(dst_var)s')))
           .Append('  return %(failure_value)s;')
           .Append('}')
         )
     elif underlying_type.property_type == PropertyType.FUNCTION:
       if is_ptr:
         c.Append('%(dst_var)s.reset(new base::DictionaryValue());')
     elif underlying_type.property_type == PropertyType.ANY:
-      c.Append('%(dst_var)s.reset(%(src_var)s->DeepCopy());')
+      c.Append('%(dst_var)s = %(src_var)s->CreateDeepCopy();')
     elif underlying_type.property_type == PropertyType.ARRAY:
       # util_cc_helper deals with optional and required arrays
       (c.Append('const base::ListValue* list = NULL;')
         .Sblock('if (!%(src_var)s->GetAsList(&list)) {')
           .Concat(self._GenerateError(
             '"\'%%(key)s\': expected list, got " + ' +
             self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
       )
       if is_ptr and self._generate_error_messages:
         c.Append('%(dst_var)s.reset();')
@@ skipping 302 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)