Remove base::FundamentalValue

components/policy/core/common/policy_map_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_map.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 77 matching lines @@
 
 TEST_F(PolicyMapTest, Equals) {
   PolicyMap a;
   SetPolicy(&a, kTestPolicyName1, base::MakeUnique<base::StringValue>("aaa"));
   PolicyMap a2;
   SetPolicy(&a2, kTestPolicyName1, base::MakeUnique<base::StringValue>("aaa"));
   PolicyMap b;
   SetPolicy(&b, kTestPolicyName1, base::MakeUnique<base::StringValue>("bbb"));
   PolicyMap c;
   SetPolicy(&c, kTestPolicyName1, base::MakeUnique<base::StringValue>("aaa"));
-  SetPolicy(&c, kTestPolicyName2,
-            base::MakeUnique<base::FundamentalValue>(true));
+  SetPolicy(&c, kTestPolicyName2, base::MakeUnique<base::Value>(true));
   PolicyMap d;
   SetPolicy(&d, kTestPolicyName1, CreateExternalDataFetcher("ddd"));
   PolicyMap d2;
   SetPolicy(&d2, kTestPolicyName1, CreateExternalDataFetcher("ddd"));
   PolicyMap e;
   SetPolicy(&e, kTestPolicyName1, CreateExternalDataFetcher("eee"));
   EXPECT_FALSE(a.Equals(b));
   EXPECT_FALSE(a.Equals(c));
   EXPECT_FALSE(a.Equals(d));
   EXPECT_FALSE(a.Equals(e));
@@ skipping 24 matching lines @@
   EXPECT_FALSE(empty1.Equals(a));
   EXPECT_FALSE(a.Equals(empty1));
 }
 
 TEST_F(PolicyMapTest, Swap) {
   PolicyMap a;
   SetPolicy(&a, kTestPolicyName1, base::MakeUnique<base::StringValue>("aaa"));
   SetPolicy(&a, kTestPolicyName2, CreateExternalDataFetcher("dummy"));
   PolicyMap b;
   SetPolicy(&b, kTestPolicyName1, base::MakeUnique<base::StringValue>("bbb"));
-  SetPolicy(&b, kTestPolicyName3,
-            base::MakeUnique<base::FundamentalValue>(true));
+  SetPolicy(&b, kTestPolicyName3, base::MakeUnique<base::Value>(true));
 
   a.Swap(&b);
   base::StringValue expected("bbb");
   EXPECT_TRUE(expected.Equals(a.GetValue(kTestPolicyName1)));
-  base::FundamentalValue expected_bool(true);
+  base::Value expected_bool(true);
   EXPECT_TRUE(expected_bool.Equals(a.GetValue(kTestPolicyName3)));
   EXPECT_FALSE(a.GetValue(kTestPolicyName2));
   EXPECT_FALSE(a.Get(kTestPolicyName2));
   base::StringValue expected_a("aaa");
   EXPECT_TRUE(expected_a.Equals(b.GetValue(kTestPolicyName1)));
   EXPECT_FALSE(b.GetValue(kTestPolicyName3));
   EXPECT_FALSE(a.GetValue(kTestPolicyName2));
   const PolicyMap::Entry* entry = b.Get(kTestPolicyName2);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(
       ExternalDataFetcher::Equals(CreateExternalDataFetcher("dummy").get(),
                                   entry->external_data_fetcher.get()));
 
   b.Clear();
   a.Swap(&b);
   PolicyMap empty;
   EXPECT_TRUE(a.Equals(empty));
   EXPECT_FALSE(b.Equals(empty));
 }
 
 TEST_F(PolicyMapTest, MergeFrom) {
   PolicyMap a;
   a.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD, base::MakeUnique<base::StringValue>("google.com"),
         nullptr);
   a.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(true),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true), nullptr);
   a.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_ENTERPRISE_DEFAULT, nullptr,
         CreateExternalDataFetcher("a"));
   a.Set(kTestPolicyName4, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(false),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(false), nullptr);
   a.Set(kTestPolicyName5, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
         base::MakeUnique<base::StringValue>("google.com/q={x}"), nullptr);
   a.Set(kTestPolicyName7, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-        POLICY_SOURCE_ENTERPRISE_DEFAULT,
-        base::MakeUnique<base::FundamentalValue>(false), nullptr);
+        POLICY_SOURCE_ENTERPRISE_DEFAULT, base::MakeUnique<base::Value>(false),
+        nullptr);
 
   PolicyMap b;
   b.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
         base::MakeUnique<base::StringValue>("chromium.org"), nullptr);
   b.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(false),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(false), nullptr);
   b.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_ENTERPRISE_DEFAULT, nullptr,
         CreateExternalDataFetcher("b"));
   b.Set(kTestPolicyName4, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE,
-        base::MakeUnique<base::FundamentalValue>(true), nullptr);
+        base::MakeUnique<base::Value>(true), nullptr);
   b.Set(kTestPolicyName5, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PLATFORM,
         base::MakeUnique<base::StringValue>(std::string()), nullptr);
   b.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(true),
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true), nullptr);
+  b.Set(kTestPolicyName7, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+        POLICY_SOURCE_ACTIVE_DIRECTORY, base::MakeUnique<base::Value>(true),
         nullptr);
-  b.Set(kTestPolicyName7, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-        POLICY_SOURCE_ACTIVE_DIRECTORY,
-        base::MakeUnique<base::FundamentalValue>(true), nullptr);
 
   a.MergeFrom(b);
 
   PolicyMap c;
   // POLICY_SCOPE_MACHINE over POLICY_SCOPE_USER.
   c.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
         base::MakeUnique<base::StringValue>("chromium.org"), nullptr);
   // |a| has precedence over |b|.
   c.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(true),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true), nullptr);
   c.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_ENTERPRISE_DEFAULT, nullptr,
         CreateExternalDataFetcher("a"));
   // POLICY_SCOPE_MACHINE over POLICY_SCOPE_USER for POLICY_LEVEL_RECOMMENDED.
   c.Set(kTestPolicyName4, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE,
-        base::MakeUnique<base::FundamentalValue>(true), nullptr);
+        base::MakeUnique<base::Value>(true), nullptr);
   // POLICY_LEVEL_MANDATORY over POLICY_LEVEL_RECOMMENDED.
   c.Set(kTestPolicyName5, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PLATFORM,
         base::MakeUnique<base::StringValue>(std::string()), nullptr);
   // Merge new ones.
   c.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(true),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true), nullptr);
   // POLICY_SOURCE_ACTIVE_DIRECTORY over POLICY_SOURCE_ENTERPRISE_DEFAULT.
   c.Set(kTestPolicyName7, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-        POLICY_SOURCE_ACTIVE_DIRECTORY,
-        base::MakeUnique<base::FundamentalValue>(true), nullptr);
+        POLICY_SOURCE_ACTIVE_DIRECTORY, base::MakeUnique<base::Value>(true),
+        nullptr);
 
   EXPECT_TRUE(a.Equals(c));
 }
 
 TEST_F(PolicyMapTest, GetDifferingKeys) {
   PolicyMap a;
   a.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD, base::MakeUnique<base::StringValue>("google.com"),
         nullptr);
   a.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("dummy"));
   a.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(true),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true), nullptr);
   a.Set(kTestPolicyName4, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("a"));
   a.Set(kTestPolicyName5, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(false),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(false), nullptr);
   a.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
         base::MakeUnique<base::StringValue>("google.com/q={x}"), nullptr);
   a.Set(kTestPolicyName7, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(true),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true), nullptr);
 
   PolicyMap b;
   b.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD, base::MakeUnique<base::StringValue>("google.com"),
         nullptr);
   b.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("dummy"));
   b.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(false),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(false), nullptr);
   b.Set(kTestPolicyName4, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("b"));
   b.Set(kTestPolicyName5, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(false),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(false), nullptr);
   b.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD,
         base::MakeUnique<base::StringValue>("google.com/q={x}"), nullptr);
   b.Set(kTestPolicyName8, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(true),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true), nullptr);
 
   std::set<std::string> diff;
   std::set<std::string> diff2;
   a.GetDifferingKeys(b, &diff);
   b.GetDifferingKeys(a, &diff2);
   // Order shouldn't matter.
   EXPECT_EQ(diff, diff2);
   // No change.
   EXPECT_TRUE(diff.find(kTestPolicyName1) == diff.end());
   EXPECT_TRUE(diff.find(kTestPolicyName2) == diff.end());
@@ skipping 23 matching lines @@
   loaded.LoadFrom(&policies,
                   POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_USER,
                   POLICY_SOURCE_PLATFORM);
 
   PolicyMap expected;
   expected.Set("TestPolicy1", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                POLICY_SOURCE_PLATFORM,
                base::MakeUnique<base::StringValue>("google.com"), nullptr);
   expected.Set("TestPolicy2", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               POLICY_SOURCE_PLATFORM,
-               base::MakeUnique<base::FundamentalValue>(true), nullptr);
+               POLICY_SOURCE_PLATFORM, base::MakeUnique<base::Value>(true),
+               nullptr);
   expected.Set("TestPolicy3", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               POLICY_SOURCE_PLATFORM,
-               base::MakeUnique<base::FundamentalValue>(-12321), nullptr);
+               POLICY_SOURCE_PLATFORM, base::MakeUnique<base::Value>(-12321),
+               nullptr);
   EXPECT_TRUE(loaded.Equals(expected));
 }
 
 bool IsMandatory(const PolicyMap::PolicyMapType::const_iterator iter) {
   return iter->second.level == POLICY_LEVEL_MANDATORY;
 }
 
 TEST_F(PolicyMapTest, EraseNonmatching) {
   PolicyMap a;
   a.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD, base::MakeUnique<base::StringValue>("google.com"),
         nullptr);
   a.Set(kTestPolicyName2, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD, base::MakeUnique<base::FundamentalValue>(true),
-        nullptr);
+        POLICY_SOURCE_CLOUD, base::MakeUnique<base::Value>(true), nullptr);
 
   a.EraseNonmatching(base::Bind(&IsMandatory));
 
   PolicyMap b;
   b.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD, base::MakeUnique<base::StringValue>("google.com"),
         nullptr);
   EXPECT_TRUE(a.Equals(b));
 }
 
 }  // namespace policy