Remove FundamentalValue

chrome/browser/chromeos/policy/configuration_policy_handler_chromeos_unittest.cc

 // 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.
 
 #include "chrome/browser/chromeos/policy/configuration_policy_handler_chromeos.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 47 matching lines @@
 TEST_F(ScreenMagnifierPolicyHandlerTest, Default) {
   handler_.ApplyPolicySettings(policy_, &prefs_);
   EXPECT_FALSE(
       prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, NULL));
   EXPECT_FALSE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, NULL));
 }
 
 TEST_F(ScreenMagnifierPolicyHandlerTest, Disabled) {
   policy_.Set(key::kScreenMagnifierType, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
-              base::MakeUnique<base::FundamentalValue>(0), nullptr);
+              base::MakeUnique<base::Value>(0), nullptr);
   handler_.ApplyPolicySettings(policy_, &prefs_);
 
   const base::Value* enabled = NULL;
   EXPECT_TRUE(
       prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, &enabled));
   ASSERT_TRUE(enabled);
-  EXPECT_TRUE(base::FundamentalValue(false).Equals(enabled));
+  EXPECT_TRUE(base::Value(false).Equals(enabled));
 
   const base::Value* type = NULL;
   EXPECT_TRUE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, &type));
   ASSERT_TRUE(type);
-  EXPECT_TRUE(base::FundamentalValue(0).Equals(type));
+  EXPECT_TRUE(base::Value(0).Equals(type));
 }
 
 TEST_F(ScreenMagnifierPolicyHandlerTest, Enabled) {
   policy_.Set(key::kScreenMagnifierType, POLICY_LEVEL_MANDATORY,
               POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
-              base::MakeUnique<base::FundamentalValue>(1), nullptr);
+              base::MakeUnique<base::Value>(1), nullptr);
   handler_.ApplyPolicySettings(policy_, &prefs_);
 
   const base::Value* enabled = NULL;
   EXPECT_TRUE(
       prefs_.GetValue(prefs::kAccessibilityScreenMagnifierEnabled, &enabled));
   ASSERT_TRUE(enabled);
-  EXPECT_TRUE(base::FundamentalValue(true).Equals(enabled));
+  EXPECT_TRUE(base::Value(true).Equals(enabled));
 
   const base::Value* type = NULL;
   EXPECT_TRUE(prefs_.GetValue(prefs::kAccessibilityScreenMagnifierType, &type));
   ASSERT_TRUE(type);
-  EXPECT_TRUE(base::FundamentalValue(1).Equals(type));
+  EXPECT_TRUE(base::Value(1).Equals(type));
 }
 
 TEST(ExternalDataPolicyHandlerTest, Empty) {
   PolicyErrorMap errors;
   EXPECT_TRUE(ExternalDataPolicyHandler(key::kUserAvatarImage)
                   .CheckPolicySettings(PolicyMap(), &errors));
   EXPECT_TRUE(errors.GetErrors(key::kUserAvatarImage).empty());
 }
 
 TEST(ExternalDataPolicyHandlerTest, WrongType) {
   PolicyMap policy_map;
   policy_map.Set(key::kUserAvatarImage, POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
-                 base::MakeUnique<base::FundamentalValue>(false), nullptr);
+                 base::MakeUnique<base::Value>(false), nullptr);
   PolicyErrorMap errors;
   EXPECT_FALSE(ExternalDataPolicyHandler(key::kUserAvatarImage)
                    .CheckPolicySettings(policy_map, &errors));
   EXPECT_FALSE(errors.GetErrors(key::kUserAvatarImage).empty());
 }
 
 TEST(ExternalDataPolicyHandlerTest, MissingURL) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
   dict->SetString("hash", "1234567890123456789012345678901234567890");
   PolicyMap policy_map;
@@ skipping 119 matching lines @@
       NetworkConfigurationPolicyHandler::CreateForUserPolicy());
   PolicyErrorMap errors;
   EXPECT_TRUE(handler->CheckPolicySettings(policy_map, &errors));
   EXPECT_TRUE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
 }
 
 TEST(NetworkConfigurationPolicyHandlerTest, WrongType) {
   PolicyMap policy_map;
   policy_map.Set(key::kOpenNetworkConfiguration, POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
-                 base::MakeUnique<base::FundamentalValue>(false), nullptr);
+                 base::MakeUnique<base::Value>(false), nullptr);
   std::unique_ptr<NetworkConfigurationPolicyHandler> handler(
       NetworkConfigurationPolicyHandler::CreateForUserPolicy());
   PolicyErrorMap errors;
   EXPECT_FALSE(handler->CheckPolicySettings(policy_map, &errors));
   EXPECT_FALSE(errors.GetErrors(key::kOpenNetworkConfiguration).empty());
 }
 
 TEST(NetworkConfigurationPolicyHandlerTest, JSONParseError) {
   const std::string kTestONC("I'm not proper JSON!");
   PolicyMap policy_map;
@@ skipping 85 matching lines @@
   LoginScreenPowerManagementPolicyHandler handler(chrome_schema_);
   PolicyErrorMap errors;
   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
   EXPECT_TRUE(errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
 }
 
 TEST_F(LoginScreenPowerManagementPolicyHandlerTest, WrongType) {
   PolicyMap policy_map;
   policy_map.Set(key::kDeviceLoginScreenPowerManagement, POLICY_LEVEL_MANDATORY,
                  POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
-                 base::MakeUnique<base::FundamentalValue>(false), nullptr);
+                 base::MakeUnique<base::Value>(false), nullptr);
   LoginScreenPowerManagementPolicyHandler handler(chrome_schema_);
   PolicyErrorMap errors;
   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
   EXPECT_FALSE(
       errors.GetErrors(key::kDeviceLoginScreenPowerManagement).empty());
 }
 
 }  // namespace policy