Remove FundamentalValue

components/policy/core/common/policy_bundle_unittest.cc

 // Copyright 2013 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/common/policy_bundle.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 15 matching lines @@
 const char kPolicy2[] = "policy-2";
 const char kExtension0[] = "extension-0";
 const char kExtension1[] = "extension-1";
 const char kExtension2[] = "extension-2";
 const char kExtension3[] = "extension-3";
 
 // Adds test policies to |policy|.
 void AddTestPolicies(PolicyMap* policy) {
   policy->Set("mandatory-user", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
               POLICY_SOURCE_CLOUD,
-              base::MakeUnique<base::FundamentalValue>(123), nullptr);
+              base::MakeUnique<base::Value>(123), nullptr);
   policy->Set("mandatory-machine", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
               POLICY_SOURCE_CLOUD, base::MakeUnique<base::StringValue>("omg"),
               nullptr);
   policy->Set("recommended-user", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
               POLICY_SOURCE_CLOUD,
-              base::MakeUnique<base::FundamentalValue>(true), nullptr);
+              base::MakeUnique<base::Value>(true), nullptr);
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetBoolean("false", false);
   dict->SetInteger("int", 456);
   dict->SetString("str", "bbq");
   policy->Set("recommended-machine", POLICY_LEVEL_RECOMMENDED,
               POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD, std::move(dict),
               nullptr);
 }
 
 // Adds test policies to |policy| based on the parameters:
 // - kPolicyClashing0 mapped to |value|, user mandatory
 // - kPolicyClashing1 mapped to |value|, with |level| and |scope|
 // - |name| mapped to |value|, user mandatory
 void AddTestPoliciesWithParams(PolicyMap *policy,
                                const char* name,
                                int value,
                                PolicyLevel level,
                                PolicyScope scope) {
   policy->Set(kPolicyClashing0, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
               POLICY_SOURCE_CLOUD,
-              base::MakeUnique<base::FundamentalValue>(value), nullptr);
+              base::MakeUnique<base::Value>(value), nullptr);
   policy->Set(kPolicyClashing1, level, scope, POLICY_SOURCE_CLOUD,
-              base::MakeUnique<base::FundamentalValue>(value), nullptr);
+              base::MakeUnique<base::Value>(value), nullptr);
   policy->Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
               POLICY_SOURCE_CLOUD,
-              base::MakeUnique<base::FundamentalValue>(value), nullptr);
+              base::MakeUnique<base::Value>(value), nullptr);
 }
 
 // Returns true if |bundle| is empty.
 bool IsEmpty(const PolicyBundle& bundle) {
   return bundle.begin() == bundle.end();
 }
 
 }  // namespace
 
 TEST(PolicyBundleTest, Get) {
@@ skipping 107 matching lines @@
   PolicyBundle empty_bundle;
   merged.MergeFrom(empty_bundle);
 
   // chrome and kExtension3 policies are merged:
   // - kPolicyClashing0 comes from bundle0, which has the highest priority;
   // - kPolicyClashing1 comes from bundle1, which has the highest level/scope
   //   combination;
   // - kPolicyN are merged from each bundle.
   PolicyMap expected;
   expected.Set(kPolicyClashing0, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(0),
+               POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(0),
                nullptr);
   expected.Set(kPolicyClashing1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-               POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(1),
+               POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(1),
                nullptr);
   expected.Set(kPolicy0, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(0),
+               POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(0),
                nullptr);
   expected.Set(kPolicy1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(1),
+               POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(1),
                nullptr);
   expected.Set(kPolicy2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(2),
+               POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(2),
                nullptr);
   EXPECT_TRUE(merged.Get(PolicyNamespace(POLICY_DOMAIN_CHROME,
                                          std::string())).Equals(expected));
   EXPECT_TRUE(merged.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                          kExtension3)).Equals(expected));
   // extension0 comes only from bundle0.
   EXPECT_TRUE(merged.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                          kExtension0)).Equals(policy0));
   // extension1 comes only from bundle1.
   EXPECT_TRUE(merged.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
@@ skipping 20 matching lines @@
   EXPECT_FALSE(bundle.Equals(other));
   other.CopyFrom(bundle);
   EXPECT_TRUE(bundle.Equals(other));
   AddTestPolicies(&other.Get(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kExtension2)));
   EXPECT_FALSE(bundle.Equals(other));
 
   other.CopyFrom(bundle);
   bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(kPolicy0, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-           POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(123),
+           POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(123),
            nullptr);
   EXPECT_FALSE(bundle.Equals(other));
   other.CopyFrom(bundle);
   EXPECT_TRUE(bundle.Equals(other));
   bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(kPolicy0, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-           POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(123),
+           POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(123),
            nullptr);
   EXPECT_FALSE(bundle.Equals(other));
 
   // Test non-const Get().
   bundle.Clear();
   other.Clear();
   PolicyMap& policy_map =
       bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()));
   EXPECT_TRUE(bundle.Equals(other));
   policy_map.Set(kPolicy0, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                  POLICY_SOURCE_CLOUD,
-                 base::MakeUnique<base::FundamentalValue>(123), nullptr);
+                 base::MakeUnique<base::Value>(123), nullptr);
   EXPECT_FALSE(bundle.Equals(other));
 }
 
 }  // namespace policy