Remove base::StringValue

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 549 matching lines @@
       .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 via std::unique_ptr.
 
     var: variable or variable*
 
-    E.g for std::string, generate new base::StringValue(var)
+    E.g for std::string, generate new base::Value(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
       # populate it with the names of the enum in the array. The |ToString|
       # function of the enum can be in another namespace when the enum is
       # referenced. Templates can not be used here because C++ templating does
       # not support passing a namespace as an argument.
@@ skipping 43 matching lines @@
           underlying_type.property_type == PropertyType.FUNCTION):
       if is_ptr:
         vardot = '(%s)->' % var
       else:
         vardot = '(%s).' % var
       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 'base::MakeUnique<base::StringValue>(%sToString(%s))' % (
+      return 'base::MakeUnique<base::Value>(%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' % 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 'base::MakeUnique<base::StringValue>(%s)' % var
+        return 'base::MakeUnique<base::Value>(%s)' % var
       else:
         return 'base::MakeUnique<base::Value>(%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.
     """
@@ skipping 488 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)