Remove base::FundamentalValue

components/policy/tools/generate_policy_source.py

 #!/usr/bin/env python
 # 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.
 
 '''python %prog [options] platform chromium_os_flag template
 
 platform specifies which platform source is being generated for
   and can be one of (win, mac, linux)
 chromium_os_flag should be 1 if this is a Chromium OS build
@@ skipping 666 matching lines @@
   """Converts a JSON object into a base::Value entry. Returns a tuple, the first
   entry being a list of declaration statements to define the variable, the
   second entry being a way to access the variable.
 
   If no definition is needed, the first return value will be an empty list. If
   any error occurs, the second return value will be None (ie, no way to fetch
   the value).
 
   |value|: The deserialized value to convert to base::Value."""
   if type(value) == bool or type(value) == int:
-    return [], 'base::MakeUnique<base::FundamentalValue>(%s)' %\
+    return [], 'base::MakeUnique<base::Value>(%s)' %\
                     json.dumps(value)
   elif type(value) == str:
     return [], 'base::MakeUnique<base::StringValue>("%s")' % value
   elif type(value) == list:
     setup = ['auto default_value = base::MakeUnique<base::ListValue>();']
     for entry in value:
       decl, fetch = _GenerateDefaultValue(entry)
       # Nested lists are not supported.
       if decl:
         return [], None
@@ skipping 428 matching lines @@
 std::unique_ptr<base::Value> DecodeIntegerValue(
     google::protobuf::int64 value) {
   if (value < std::numeric_limits<int>::min() ||
       value > std::numeric_limits<int>::max()) {
     LOG(WARNING) << "Integer value " << value
                  << " out of numeric limits, ignoring.";
     return nullptr;
   }
 
   return base::WrapUnique(
-      new base::FundamentalValue(static_cast<int>(value)));
+      new base::Value(static_cast<int>(value)));
 }
 
 std::unique_ptr<base::ListValue> DecodeStringList(
     const em::StringList& string_list) {
   std::unique_ptr<base::ListValue> list_value(new base::ListValue);
   for (const auto& entry : string_list.entries())
     list_value->AppendString(entry);
   return list_value;
 }
 
@@ skipping 16 matching lines @@
 
 
 CPP_FOOT = '''}
 
 }  // namespace policy
 '''
 
 
 def _CreateValue(type, arg):
   if type == 'Type::BOOLEAN':
-    return 'new base::FundamentalValue(%s)' % arg
+    return 'new base::Value(%s)' % arg
   elif type == 'Type::INTEGER':
     return 'DecodeIntegerValue(%s)' % arg
   elif type == 'Type::STRING':
     return 'new base::StringValue(%s)' % arg
   elif type == 'Type::LIST':
     return 'DecodeStringList(%s)' % arg
   elif type == 'Type::DICTIONARY' or type == 'TYPE_EXTERNAL':
     return 'DecodeJson(%s)' % arg
   else:
     raise NotImplementedError('Unknown type %s' % type)
@@ skipping 84 matching lines @@
   f.write('<restrictions xmlns:android="'
           'http://schemas.android.com/apk/res/android">\n\n')
   for policy in policies:
     if (policy.is_supported and policy.restriction_type != 'invalid' and
          not policy.is_deprecated and not policy.is_future):
       WriteAppRestriction(policy)
   f.write('</restrictions>')
 
 if __name__ == '__main__':
   sys.exit(main())