Remove base::FundamentalValue

components/policy/core/browser/android/policy_converter.cc

 // Copyright 2015 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 "components/policy/core/browser/android/policy_converter.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/android/jni_android.h"
@@ skipping 38 matching lines @@
 }
 
 base::android::ScopedJavaLocalRef<jobject> PolicyConverter::GetJavaObject() {
   return base::android::ScopedJavaLocalRef<jobject>(java_obj_);
 }
 
 void PolicyConverter::SetPolicyBoolean(JNIEnv* env,
                                        const JavaRef<jobject>& obj,
                                        const JavaRef<jstring>& policyKey,
                                        jboolean value) {
-  SetPolicyValue(
-      ConvertJavaStringToUTF8(env, policyKey),
-      base::MakeUnique<base::FundamentalValue>(static_cast<bool>(value)));
+  SetPolicyValue(ConvertJavaStringToUTF8(env, policyKey),
+                 base::MakeUnique<base::Value>(static_cast<bool>(value)));
 }
 
 void PolicyConverter::SetPolicyInteger(JNIEnv* env,
                                        const JavaRef<jobject>& obj,
                                        const JavaRef<jstring>& policyKey,
                                        jint value) {
-  SetPolicyValue(
-      ConvertJavaStringToUTF8(env, policyKey),
-      base::MakeUnique<base::FundamentalValue>(static_cast<int>(value)));
+  SetPolicyValue(ConvertJavaStringToUTF8(env, policyKey),
+                 base::MakeUnique<base::Value>(static_cast<int>(value)));
 }
 
 void PolicyConverter::SetPolicyString(JNIEnv* env,
                                       const JavaRef<jobject>& obj,
                                       const JavaRef<jstring>& policyKey,
                                       const JavaRef<jstring>& value) {
   SetPolicyValue(
       ConvertJavaStringToUTF8(env, policyKey),
       base::MakeUnique<base::StringValue>(ConvertJavaStringToUTF8(env, value)));
 }
@@ skipping 33 matching lines @@
     return value;
 
   switch (schema.type()) {
     case base::Value::Type::NONE:
       return base::Value::CreateNullValue();
 
     case base::Value::Type::BOOLEAN: {
       std::string string_value;
       if (value->GetAsString(&string_value)) {
         if (string_value.compare("true") == 0)
-          return base::MakeUnique<base::FundamentalValue>(true);
+          return base::MakeUnique<base::Value>(true);
 
         if (string_value.compare("false") == 0)
-          return base::MakeUnique<base::FundamentalValue>(false);
+          return base::MakeUnique<base::Value>(false);
 
         return value;
       }
       int int_value = 0;
       if (value->GetAsInteger(&int_value))
-        return base::MakeUnique<base::FundamentalValue>(int_value != 0);
+        return base::MakeUnique<base::Value>(int_value != 0);
 
       return value;
     }
 
     case base::Value::Type::INTEGER: {
       std::string string_value;
       if (value->GetAsString(&string_value)) {
         int int_value = 0;
         if (base::StringToInt(string_value, &int_value))
-          return base::MakeUnique<base::FundamentalValue>(int_value);
+          return base::MakeUnique<base::Value>(int_value);
       }
       return value;
     }
 
     case base::Value::Type::DOUBLE: {
       std::string string_value;
       if (value->GetAsString(&string_value)) {
         double double_value = 0;
         if (base::StringToDouble(string_value, &double_value))
-          return base::MakeUnique<base::FundamentalValue>(double_value);
+          return base::MakeUnique<base::Value>(double_value);
       }
       return value;
     }
 
     // String can't be converted from other types.
     case base::Value::Type::STRING: {
       return value;
     }
 
     // Binary is not a valid schema type.
@@ skipping 29 matching lines @@
                                      std::unique_ptr<base::Value> value) {
   const Schema schema = policy_schema_->GetKnownProperty(key);
   const PolicyNamespace ns(POLICY_DOMAIN_CHROME, std::string());
   policy_bundle_->Get(ns).Set(
       key, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM,
       ConvertValueToSchema(std::move(value), schema), nullptr);
 }
 
 }  // namespace android
 }  // namespace policy