more changes

chrome/browser/policy/user_policy_cache.cc

 // Copyright (c) 2011 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.
 
 #include "chrome/browser/policy/user_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 156 matching lines @@
 
 Value* UserPolicyCache::DecodeIntegerValue(
     google::protobuf::int64 value) const {
   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::NumberValue::New(static_cast<int>(value));
 }
 
 Value* UserPolicyCache::DecodeValue(const em::GenericValue& value) const {
   if (!value.has_value_type())
     return NULL;
 
   switch (value.value_type()) {
     case em::GenericValue::VALUE_TYPE_BOOL:
       if (value.has_bool_value())
-        return Value::CreateBooleanValue(value.bool_value());
+        return base::BooleanValue::New(value.bool_value());
       return NULL;
     case em::GenericValue::VALUE_TYPE_INT64:
       if (value.has_int64_value())
         return DecodeIntegerValue(value.int64_value());
       return NULL;
     case em::GenericValue::VALUE_TYPE_STRING:
       if (value.has_string_value())
-        return Value::CreateStringValue(value.string_value());
+        return base::StringValue::New(value.string_value());
       return NULL;
     case em::GenericValue::VALUE_TYPE_DOUBLE:
       if (value.has_double_value())
-        return Value::CreateDoubleValue(value.double_value());
+        return base::NumberValue::New(value.double_value());
       return NULL;
     case em::GenericValue::VALUE_TYPE_BYTES:
       if (value.has_bytes_value()) {
         std::string bytes = value.bytes_value();
         return base::BinaryValue::CreateWithCopiedBuffer(bytes.c_str(),
                                                          bytes.size());
       }
       return NULL;
     case em::GenericValue::VALUE_TYPE_BOOL_ARRAY: {
       ListValue* list = new ListValue;
       RepeatedField<bool>::const_iterator i;
       for (i = value.bool_array().begin(); i != value.bool_array().end(); ++i)
-        list->Append(Value::CreateBooleanValue(*i));
+        list->Append(base::BooleanValue::New(*i));
       return list;
     }
     case em::GenericValue::VALUE_TYPE_INT64_ARRAY: {
       ListValue* list = new ListValue;
       RepeatedField<google::protobuf::int64>::const_iterator i;
       for (i = value.int64_array().begin();
            i != value.int64_array().end(); ++i) {
         Value* int_value = DecodeIntegerValue(*i);
         if (int_value)
           list->Append(int_value);
       }
       return list;
     }
     case em::GenericValue::VALUE_TYPE_STRING_ARRAY: {
       ListValue* list = new ListValue;
       RepeatedPtrField<std::string>::const_iterator i;
       for (i = value.string_array().begin();
            i != value.string_array().end(); ++i)
-        list->Append(Value::CreateStringValue(*i));
+        list->Append(base::StringValue::New(*i));
       return list;
     }
     case em::GenericValue::VALUE_TYPE_DOUBLE_ARRAY: {
       ListValue* list = new ListValue;
       RepeatedField<double>::const_iterator i;
       for (i = value.double_array().begin();
            i != value.double_array().end(); ++i)
-        list->Append(Value::CreateDoubleValue(*i));
+        list->Append(base::NumberValue::New(*i));
       return list;
     }
     default:
       NOTREACHED() << "Unhandled value type";
   }
 
   return NULL;
 }
 
 }  // namespace policy