Add base namespace to more values in sync and elsewhere.

chrome/tools/build/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 226 matching lines @@
           '#include "base/logging.h"\n'
           '#include "policy/policy_constants.h"\n'
           '\n'
           'namespace policy {\n\n')
 
   f.write('namespace {\n\n')
 
   f.write('const PolicyDefinitionList::Entry kEntries[] = {\n')
   for policy in policies:
     if policy.is_supported:
-      f.write('  { key::k%s, Value::%s, %s, %s },\n' %
+      f.write('  { key::k%s, base::Value::%s, %s, %s },\n' %
           (policy.name, policy.value_type,
               'true' if policy.is_device_only else 'false', policy.id))
   f.write('};\n\n')
 
   f.write('const PolicyDefinitionList kChromePolicyList = {\n'
           '  kEntries,\n'
           '  kEntries + arraysize(kEntries),\n'
           '};\n\n')
 
   has_deprecated_policies = any(
@@ skipping 159 matching lines @@
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "policy/proto/cloud_policy.pb.h"
 
 using google::protobuf::RepeatedPtrField;
 
 namespace policy {
 
 namespace em = enterprise_management;
 
-Value* DecodeIntegerValue(google::protobuf::int64 value) {
+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 NULL;
   }
 
-  return Value::CreateIntegerValue(static_cast<int>(value));
+  return base::Value::CreateIntegerValue(static_cast<int>(value));
 }
 
-ListValue* DecodeStringList(const em::StringList& string_list) {
-  ListValue* list_value = new ListValue;
+base::ListValue* DecodeStringList(const em::StringList& string_list) {
+  base::ListValue* list_value = new base::ListValue;
   RepeatedPtrField<std::string>::const_iterator entry;
   for (entry = string_list.entries().begin();
        entry != string_list.entries().end(); ++entry) {
-    list_value->Append(Value::CreateStringValue(*entry));
+    list_value->Append(base::Value::CreateStringValue(*entry));
   }
   return list_value;
 }
 
 void DecodePolicy(const em::CloudPolicySettings& policy, PolicyMap* map) {
 '''
 
 
 CPP_FOOT = '''}
 
 }  // namespace policy
 '''
 
 
 def _CreateValue(type, arg):
   if type == 'TYPE_BOOLEAN':
-    return 'Value::CreateBooleanValue(%s)' % arg
+    return 'base::Value::CreateBooleanValue(%s)' % arg
   elif type == 'TYPE_INTEGER':
     return 'DecodeIntegerValue(%s)' % arg
   elif type == 'TYPE_STRING':
-    return 'Value::CreateStringValue(%s)' % arg
+    return 'base::Value::CreateStringValue(%s)' % arg
   elif type == 'TYPE_LIST':
     return 'DecodeStringList(%s)' % arg
   elif type == 'TYPE_DICTIONARY':
     # TODO(joaodasilva): decode 'dict' types. http://crbug.com/108997
-    return 'new DictionaryValue()'
+    return 'new base::DictionaryValue()'
   else:
     raise NotImplementedError('Unknown type %s' % type)
 
 
 def _WritePolicyCode(f, policy):
   membername = policy.name.lower()
   proto_type = '%sPolicyProto' % policy.policy_protobuf_type
   f.write('  if (policy.has_%s()) {\n' % membername)
   f.write('    const em::%s& policy_proto = policy.%s();\n' %
           (proto_type, membername))
   f.write('    if (policy_proto.has_value()) {\n')
   f.write('      PolicyLevel level = POLICY_LEVEL_MANDATORY;\n'
           '      bool do_set = true;\n'
           '      if (policy_proto.has_policy_options()) {\n'
           '        do_set = false;\n'
           '        switch(policy_proto.policy_options().mode()) {\n'
           '          case em::PolicyOptions::MANDATORY:\n'
           '            do_set = true;\n'
           '            level = POLICY_LEVEL_MANDATORY;\n'
           '            break;\n'
           '          case em::PolicyOptions::RECOMMENDED:\n'
           '            do_set = true;\n'
           '            level = POLICY_LEVEL_RECOMMENDED;\n'
           '            break;\n'
           '          case em::PolicyOptions::UNSET:\n'
           '            break;\n'
           '        }\n'
           '      }\n'
           '      if (do_set) {\n')
-  f.write('        Value* value = %s;\n' %
+  f.write('        base::Value* value = %s;\n' %
           (_CreateValue(policy.value_type, 'policy_proto.value()')))
   f.write('        map->Set(key::k%s, level, POLICY_SCOPE_USER, value);\n' %
           policy.name)
   f.write('      }\n'
           '    }\n'
           '  }\n')
 
 
 def _WriteCloudPolicyDecoder(policies, os, f):
   f.write(CPP_HEAD)
   for policy in policies:
     if policy.is_supported and not policy.is_device_only:
       _WritePolicyCode(f, policy)
   f.write(CPP_FOOT)
 
 
 if __name__ == '__main__':
   sys.exit(main())