json_schema_compiler: Use std::vector<char> for binary values.

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/stl_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>')
       .Cblock(self._type_helper.GenerateIncludes(include_soft=True))
       .Append()
       .Append('using base::UTF8ToUTF16;')
       .Append()
       .Concat(cpp_util.OpenNamespace(cpp_namespace))
@@ skipping 97 matching lines @@
       elif prop.optional:
         continue
       elif t.property_type == PropertyType.INTEGER:
         items.append('%s(0)' % prop.unix_name)
       elif t.property_type == PropertyType.DOUBLE:
         items.append('%s(0.0)' % prop.unix_name)
       elif t.property_type == PropertyType.BOOLEAN:
         items.append('%s(false)' % prop.unix_name)
       elif (t.property_type == PropertyType.ANY or
             t.property_type == PropertyType.ARRAY or
-            t.property_type == PropertyType.BINARY or  # mapped to std::string
+            t.property_type == PropertyType.BINARY or
             t.property_type == PropertyType.CHOICES or
             t.property_type == PropertyType.OBJECT or
             t.property_type == PropertyType.FUNCTION or
             t.property_type == PropertyType.REF or
             t.property_type == PropertyType.STRING):
         # TODO(miket): It would be nice to initialize CHOICES, but we
         # don't presently have the semantics to indicate which one of a set
         # should be the default.
         continue
       else:
@@ skipping 360 matching lines @@
         vardot = '(%s).' % var
       return '%sDeepCopy()' % 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)
     elif underlying_type.property_type == PropertyType.BINARY:
       if is_ptr:
         vardot = var + '->'
+        ref = var + '.get()'
       else:
         vardot = var + '.'
-      return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' %
-              (vardot, vardot))
+        ref = '&' + var
+      return ('base::BinaryValue::CreateWithCopiedBuffer(vector_as_array(%s),'
+              ' %ssize())' % (ref, vardot))
     elif underlying_type.property_type == PropertyType.ARRAY:
       return '%s.release()' % 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
       else:
@@ skipping 242 matching lines @@
           self._util_cc_helper.GetValueTypeString('%%(src_var)s', True)))
       )
       if not self._generate_error_messages:
         c.Append('return %(failure_value)s;')
       (c.Eblock('}')
         .Sblock('else {')
         .Append(' binary_value =')
         .Append('   static_cast<const base::BinaryValue*>(%(src_var)s);')
       )
       if is_ptr:
-        (c.Append('%(dst_var)s.reset(')
-          .Append('    new std::string(binary_value->GetBuffer(),')
-          .Append('                    binary_value->GetSize()));')
+        (c.Append('%(dst_var)s.reset(new std::vector<char>(')
+          .Append('    binary_value->GetBuffer(),')
+          .Append('    binary_value->GetBuffer() + binary_value->GetSize()));')
         )
       else:
-        (c.Append('%(dst_var)s.assign(binary_value->GetBuffer(),')
-          .Append('                   binary_value->GetSize());')
+        (c.Append('%(dst_var)s.assign(')
+          .Append('    binary_value->GetBuffer(),')
+          .Append('    binary_value->GetBuffer() + binary_value->GetSize());')
         )
       c.Eblock('}')
     else:
       raise NotImplementedError(type_)
     if c.IsEmpty():
       return c
     return Code().Sblock('{').Concat(c.Substitute({
       'cpp_type': self._type_helper.GetCppType(type_),
       'src_var': src_var,
       'dst_var': dst_var,
@@ skipping 221 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)