Represent BINARY properties using std::string instead of BinaryValue,

tools/json_schema_compiler/cpp_type_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 any_helper
 import cpp_util
 import schema_util
 
@@ skipping 100 matching lines @@
 
     If REF types from different namespaces are referenced, will resolve
     using self._type_namespaces.
 
     Use pad_for_generics when using as a generic to avoid operator ambiguity.
 
     Use wrap_optional to wrap the type in a scoped_ptr<T> if the Property is
     optional.
     """
     cpp_type = None
-    force_wrapping = False
     if prop.type_ == PropertyType.REF:
       dependency_namespace = self._ResolveTypeNamespace(prop.ref_type)
       if not dependency_namespace:
         raise KeyError('Cannot find referenced type: %s' % prop.ref_type)
       if self._namespace != dependency_namespace:
         cpp_type = '%s::%s' % (self._cpp_namespaces[dependency_namespace],
             schema_util.StripSchemaNamespace(prop.ref_type))
       else:
         cpp_type = schema_util.StripSchemaNamespace(prop.ref_type)
     elif prop.type_ == PropertyType.BOOLEAN:
@@ skipping 17 matching lines @@
       if item_type.type_ == PropertyType.REF:
         item_type = self.GetReferencedProperty(item_type)
       if item_type.type_ in (
           PropertyType.REF, PropertyType.ANY, PropertyType.OBJECT):
         cpp_type = 'std::vector<linked_ptr<%s> > '
       else:
         cpp_type = 'std::vector<%s> '
       cpp_type = cpp_type % self.GetType(
           prop.item_type, pad_for_generics=True)
     elif prop.type_ == PropertyType.BINARY:
-      # Since base::BinaryValue's are immutable, we wrap them in a scoped_ptr to
-      # allow them to be modified after the fact.
-      force_wrapping = True
-      cpp_type = 'base::BinaryValue'
+      cpp_type = 'std::string'
     else:
       raise NotImplementedError(prop.type_)
 
     # Enums aren't wrapped because C++ won't allow it. Optional enums have a
     # NONE value generated instead.
-    if force_wrapping or (wrap_optional and prop.optional and prop.type_ !=
-                          PropertyType.ENUM):
+    if wrap_optional and prop.optional and prop.type_ != PropertyType.ENUM:
       cpp_type = 'scoped_ptr<%s> ' % cpp_type
     if pad_for_generics:
       return cpp_type
     return cpp_type.strip()
 
   def GenerateForwardDeclarations(self):
     """Returns the forward declarations for self._namespace.
 
     Use after GetRootNamespaceStart. Assumes all namespaces are relative to
     self._root_namespace.
@@ skipping 127 matching lines @@
     """
     if type_ == PropertyType.BOOLEAN:
       return 'bool'
     elif type_ == PropertyType.INTEGER:
       return 'int'
     elif type_ == PropertyType.DOUBLE:
       return 'double'
     elif type_ == PropertyType.STRING:
       return 'char*'
     raise Exception(type_ + ' is not primitive')