Migrate PolicyMap::Set to use base::Value

Changed PolicyMap::Set to use the newer version with
value parameter passed as base::Value instead of unique_ptr.

Bug: 2270317
Change-Id: I6aa11ff068e19ab9017d63c116c3f830b1643a8a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2275881Reviewed-by: Maksim Ivanov <emaxx@chromium.org>
Reviewed-by: Parastoo Geranmayeh <parastoog@google.com>
Commit-Queue: Aya Elsayed <ayaelattar@google.com>
Cr-Commit-Position: refs/heads/master@{#784486}

components/autofill/core/browser/autofill_policy_handler_unittest.cc

@@ -31,7 +31,7 @@ TEST_F(AutofillPolicyHandlerTest, Enabled) {
   policy::PolicyMap policy;
   policy.Set(policy::key::kAutoFillEnabled, policy::POLICY_LEVEL_MANDATORY,
              policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(true), nullptr);
+             base::Value(true), nullptr);
   PrefValueMap prefs;
   AutofillPolicyHandler handler;
   handler.ApplyPolicySettings(policy, &prefs);
@@ -50,7 +50,7 @@ TEST_F(AutofillPolicyHandlerTest, Disabled) {
   policy::PolicyMap policy;
   policy.Set(policy::key::kAutoFillEnabled, policy::POLICY_LEVEL_MANDATORY,
              policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(false), nullptr);
+             base::Value(false), nullptr);
   PrefValueMap prefs;
   AutofillPolicyHandler handler;
   handler.ApplyPolicySettings(policy, &prefs);
@@ -80,11 +80,10 @@ TEST_F(AutofillPolicyHandlerTest, DeprecatedPolicyIgnored_AddressEnabled) {
   policy::PolicyMap policy;
   policy.Set(policy::key::kAutoFillEnabled, policy::POLICY_LEVEL_MANDATORY,
              policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(false), nullptr);
+             base::Value(false), nullptr);
   policy.Set(policy::key::kAutofillAddressEnabled,
              policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
-             policy::POLICY_SOURCE_CLOUD, std::make_unique<base::Value>(false),
-             nullptr);
+             policy::POLICY_SOURCE_CLOUD, base::Value(false), nullptr);
   PrefValueMap prefs;
   AutofillPolicyHandler handler;
   handler.ApplyPolicySettings(policy, &prefs);
@@ -104,11 +103,10 @@ TEST_F(AutofillPolicyHandlerTest, DeprecatedPolicyIgnored_CreditCardEnabled) {
   policy::PolicyMap policy;
   policy.Set(policy::key::kAutoFillEnabled, policy::POLICY_LEVEL_MANDATORY,
              policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(false), nullptr);
+             base::Value(false), nullptr);
   policy.Set(policy::key::kAutofillCreditCardEnabled,
              policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
-             policy::POLICY_SOURCE_CLOUD, std::make_unique<base::Value>(false),
-             nullptr);
+             policy::POLICY_SOURCE_CLOUD, base::Value(false), nullptr);
   PrefValueMap prefs;
   AutofillPolicyHandler handler;
   handler.ApplyPolicySettings(policy, &prefs);

components/policy/core/browser/proxy_policy_handler_unittest.cc

@@ -76,16 +76,14 @@ class ProxyPolicyHandlerTest
 TEST_F(ProxyPolicyHandlerTest, ManualOptions) {
   PolicyMap policy;
   policy.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>("http://chromium.org/override"),
+             POLICY_SOURCE_CLOUD, base::Value("http://chromium.org/override"),
              nullptr);
   policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD, std::make_unique<base::Value>("chromium.org"),
-             nullptr);
+             POLICY_SOURCE_CLOUD, base::Value("chromium.org"), nullptr);
   policy.Set(
       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       POLICY_SOURCE_CLOUD,
-      std::make_unique<base::Value>(
+      base::Value(
           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
       nullptr);
   UpdateProviderPolicy(policy);
@@ -101,16 +99,14 @@ TEST_F(ProxyPolicyHandlerTest, ManualOptionsReversedApplyOrder) {
   policy.Set(
       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       POLICY_SOURCE_CLOUD,
-      std::make_unique<base::Value>(
+      base::Value(
           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
       nullptr);
   policy.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>("http://chromium.org/override"),
+             POLICY_SOURCE_CLOUD, base::Value("http://chromium.org/override"),
              nullptr);
   policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD, std::make_unique<base::Value>("chromium.org"),
-             nullptr);
+             POLICY_SOURCE_CLOUD, base::Value("chromium.org"), nullptr);
   UpdateProviderPolicy(policy);
 
   VerifyProxyPrefs("chromium.org",
@@ -124,7 +120,7 @@ TEST_F(ProxyPolicyHandlerTest, ManualOptionsInvalid) {
   policy.Set(
       key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       POLICY_SOURCE_CLOUD,
-      std::make_unique<base::Value>(
+      base::Value(
           ProxyPolicyHandler::PROXY_MANUALLY_CONFIGURED_PROXY_SERVER_MODE),
       nullptr);
   UpdateProviderPolicy(policy);
@@ -135,11 +131,9 @@ TEST_F(ProxyPolicyHandlerTest, ManualOptionsInvalid) {
 
 TEST_F(ProxyPolicyHandlerTest, NoProxyServerMode) {
   PolicyMap policy;
-  policy.Set(
-      key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+  policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
-      std::make_unique<base::Value>(ProxyPolicyHandler::PROXY_SERVER_MODE),
-      nullptr);
+             base::Value(ProxyPolicyHandler::PROXY_SERVER_MODE), nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(
       std::string(), std::string(), std::string(), ProxyPrefs::MODE_DIRECT);
@@ -148,8 +142,7 @@ TEST_F(ProxyPolicyHandlerTest, NoProxyServerMode) {
 TEST_F(ProxyPolicyHandlerTest, NoProxyModeName) {
   PolicyMap policy;
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(ProxyPrefs::kDirectProxyModeName),
+             POLICY_SOURCE_CLOUD, base::Value(ProxyPrefs::kDirectProxyModeName),
              nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(
@@ -158,10 +151,10 @@ TEST_F(ProxyPolicyHandlerTest, NoProxyModeName) {
 
 TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyServerMode) {
   PolicyMap policy;
-  policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+  policy.Set(
+      key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(
-                 ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE),
+      base::Value(ProxyPolicyHandler::PROXY_AUTO_DETECT_PROXY_SERVER_MODE),
       nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(std::string(),
@@ -172,11 +165,9 @@ TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyServerMode) {
 
 TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyModeName) {
   PolicyMap policy;
-  policy.Set(
-      key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+  policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
-      std::make_unique<base::Value>(ProxyPrefs::kAutoDetectProxyModeName),
-      nullptr);
+             base::Value(ProxyPrefs::kAutoDetectProxyModeName), nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(std::string(),
                    std::string(),
@@ -187,13 +178,11 @@ TEST_F(ProxyPolicyHandlerTest, AutoDetectProxyModeName) {
 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyMode) {
   PolicyMap policy;
   policy.Set(key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>("http://short.org/proxy.pac"),
+             POLICY_SOURCE_CLOUD, base::Value("http://short.org/proxy.pac"),
              nullptr);
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(ProxyPrefs::kPacScriptProxyModeName),
-             nullptr);
+             base::Value(ProxyPrefs::kPacScriptProxyModeName), nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(std::string(),
                    "http://short.org/proxy.pac",
@@ -205,8 +194,7 @@ TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeInvalid) {
   PolicyMap policy;
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(ProxyPrefs::kPacScriptProxyModeName),
-             nullptr);
+             base::Value(ProxyPrefs::kPacScriptProxyModeName), nullptr);
   UpdateProviderPolicy(policy);
   const base::Value* value = nullptr;
   EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value));
@@ -217,16 +205,13 @@ TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeInvalid) {
 TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeBug78016) {
   PolicyMap policy;
   policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD, std::make_unique<base::Value>(std::string()),
-             nullptr);
+             POLICY_SOURCE_CLOUD, base::Value(std::string()), nullptr);
   policy.Set(key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>("http://short.org/proxy.pac"),
+             POLICY_SOURCE_CLOUD, base::Value("http://short.org/proxy.pac"),
              nullptr);
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(ProxyPrefs::kPacScriptProxyModeName),
-             nullptr);
+             base::Value(ProxyPrefs::kPacScriptProxyModeName), nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(std::string(),
                    "http://short.org/proxy.pac",
@@ -236,10 +221,10 @@ TEST_F(ProxyPolicyHandlerTest, PacScriptProxyModeBug78016) {
 
 TEST_F(ProxyPolicyHandlerTest, UseSystemProxyServerMode) {
   PolicyMap policy;
-  policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+  policy.Set(
+      key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
       POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(
-                 ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE),
+      base::Value(ProxyPolicyHandler::PROXY_USE_SYSTEM_PROXY_SERVER_MODE),
       nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(
@@ -249,8 +234,7 @@ TEST_F(ProxyPolicyHandlerTest, UseSystemProxyServerMode) {
 TEST_F(ProxyPolicyHandlerTest, UseSystemProxyMode) {
   PolicyMap policy;
   policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>(ProxyPrefs::kSystemProxyModeName),
+             POLICY_SOURCE_CLOUD, base::Value(ProxyPrefs::kSystemProxyModeName),
              nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(
@@ -260,16 +244,12 @@ TEST_F(ProxyPolicyHandlerTest, UseSystemProxyMode) {
 TEST_F(ProxyPolicyHandlerTest,
        ProxyModeOverridesProxyServerMode) {
   PolicyMap policy;
-  policy.Set(
-      key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+  policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
-      std::make_unique<base::Value>(ProxyPolicyHandler::PROXY_SERVER_MODE),
-      nullptr);
-  policy.Set(
-      key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+             base::Value(ProxyPolicyHandler::PROXY_SERVER_MODE), nullptr);
+  policy.Set(key::kProxyMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
              POLICY_SOURCE_CLOUD,
-      std::make_unique<base::Value>(ProxyPrefs::kAutoDetectProxyModeName),
-      nullptr);
+             base::Value(ProxyPrefs::kAutoDetectProxyModeName), nullptr);
   UpdateProviderPolicy(policy);
   VerifyProxyPrefs(std::string(),
                    std::string(),
@@ -281,19 +261,16 @@ TEST_F(ProxyPolicyHandlerTest, ProxyInvalid) {
   // No mode expects all three parameters being set.
   PolicyMap policy;
   policy.Set(key::kProxyPacUrl, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>("http://short.org/proxy.pac"),
+             POLICY_SOURCE_CLOUD, base::Value("http://short.org/proxy.pac"),
              nullptr);
   policy.Set(key::kProxyBypassList, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD,
-             std::make_unique<base::Value>("http://chromium.org/override"),
+             POLICY_SOURCE_CLOUD, base::Value("http://chromium.org/override"),
              nullptr);
   policy.Set(key::kProxyServer, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-             POLICY_SOURCE_CLOUD, std::make_unique<base::Value>("chromium.org"),
-             nullptr);
+             POLICY_SOURCE_CLOUD, base::Value("chromium.org"), nullptr);
   for (int i = 0; i < ProxyPolicyHandler::MODE_COUNT; ++i) {
     policy.Set(key::kProxyServerMode, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               POLICY_SOURCE_CLOUD, std::make_unique<base::Value>(i), nullptr);
+               POLICY_SOURCE_CLOUD, base::Value(i), nullptr);
     UpdateProviderPolicy(policy);
     const base::Value* value = nullptr;
     EXPECT_FALSE(store_->GetValue(proxy_config::prefs::kProxy, &value));

components/policy/core/browser/url_blacklist_policy_handler_unittest.cc

@@ -32,11 +32,11 @@ const char kTestBlacklistValue[] = "kTestBlacklistValue";
 
 class URLBlacklistPolicyHandlerTest : public testing::Test {
  protected:
-  void SetPolicy(const std::string& key, std::unique_ptr<base::Value> value) {
+  void SetPolicy(const std::string& key, base::Value value) {
     policies_.Set(key, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                   POLICY_SOURCE_CLOUD, std::move(value), nullptr);
   }
-  bool CheckPolicy(const std::string& key, std::unique_ptr<base::Value> value) {
+  bool CheckPolicy(const std::string& key, base::Value value) {
     SetPolicy(key, std::move(value));
     return handler_.CheckPolicySettings(policies_, &errors_);
   }
@@ -53,22 +53,21 @@ class URLBlacklistPolicyHandlerTest : public testing::Test {
 TEST_F(URLBlacklistPolicyHandlerTest,
        CheckPolicySettings_DisabledSchemesUnspecified) {
   EXPECT_TRUE(
-      CheckPolicy(key::kURLBlacklist, std::make_unique<base::ListValue>()));
+      CheckPolicy(key::kURLBlacklist, base::Value(base::Value::Type::LIST)));
   EXPECT_EQ(0U, errors_.size());
 }
 
 TEST_F(URLBlacklistPolicyHandlerTest,
        CheckPolicySettings_URLBlacklistUnspecified) {
   EXPECT_TRUE(
-      CheckPolicy(key::kDisabledSchemes, std::make_unique<base::ListValue>()));
+      CheckPolicy(key::kDisabledSchemes, base::Value(base::Value::Type::LIST)));
   EXPECT_EQ(0U, errors_.size());
 }
 
 TEST_F(URLBlacklistPolicyHandlerTest,
        CheckPolicySettings_DisabledSchemesWrongType) {
   // The policy expects a list. Give it a boolean.
-  EXPECT_TRUE(
-      CheckPolicy(key::kDisabledSchemes, std::make_unique<base::Value>(false)));
+  EXPECT_TRUE(CheckPolicy(key::kDisabledSchemes, base::Value(false)));
   EXPECT_EQ(1U, errors_.size());
   const std::string expected = key::kDisabledSchemes;
   const std::string actual = errors_.begin()->first;
@@ -78,8 +77,7 @@ TEST_F(URLBlacklistPolicyHandlerTest,
 TEST_F(URLBlacklistPolicyHandlerTest,
        CheckPolicySettings_URLBlacklistWrongType) {
   // The policy expects a list. Give it a boolean.
-  EXPECT_TRUE(
-      CheckPolicy(key::kURLBlacklist, std::make_unique<base::Value>(false)));
+  EXPECT_TRUE(CheckPolicy(key::kURLBlacklist, base::Value(false)));
   EXPECT_EQ(1U, errors_.size());
   const std::string expected = key::kURLBlacklist;
   const std::string actual = errors_.begin()->first;
@@ -94,7 +92,7 @@ TEST_F(URLBlacklistPolicyHandlerTest, ApplyPolicySettings_NothingSpecified) {
 TEST_F(URLBlacklistPolicyHandlerTest,
        ApplyPolicySettings_DisabledSchemesWrongType) {
   // The policy expects a list. Give it a boolean.
-  SetPolicy(key::kDisabledSchemes, std::make_unique<base::Value>(false));
+  SetPolicy(key::kDisabledSchemes, base::Value(false));
   ApplyPolicies();
   EXPECT_FALSE(prefs_.GetValue(policy_prefs::kUrlBlacklist, nullptr));
 }
@@ -102,14 +100,14 @@ TEST_F(URLBlacklistPolicyHandlerTest,
 TEST_F(URLBlacklistPolicyHandlerTest,
        ApplyPolicySettings_URLBlacklistWrongType) {
   // The policy expects a list. Give it a boolean.
-  SetPolicy(key::kURLBlacklist, std::make_unique<base::Value>(false));
+  SetPolicy(key::kURLBlacklist, base::Value(false));
   ApplyPolicies();
   EXPECT_FALSE(prefs_.GetValue(policy_prefs::kUrlBlacklist, nullptr));
 }
 
 TEST_F(URLBlacklistPolicyHandlerTest,
        ApplyPolicySettings_DisabledSchemesEmpty) {
-  SetPolicy(key::kDisabledSchemes, std::make_unique<base::ListValue>());
+  SetPolicy(key::kDisabledSchemes, base::Value(base::Value::Type::LIST));
   ApplyPolicies();
   base::Value* out;
   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
@@ -120,7 +118,7 @@ TEST_F(URLBlacklistPolicyHandlerTest,
 
 TEST_F(URLBlacklistPolicyHandlerTest,
        ApplyPolicySettings_URLBlacklistEmpty) {
-  SetPolicy(key::kURLBlacklist, std::make_unique<base::ListValue>());
+  SetPolicy(key::kURLBlacklist, base::Value(base::Value::Type::LIST));
   ApplyPolicies();
   base::Value* out;
   EXPECT_TRUE(prefs_.GetValue(policy_prefs::kUrlBlacklist, &out));
@@ -132,8 +130,8 @@ TEST_F(URLBlacklistPolicyHandlerTest,
 TEST_F(URLBlacklistPolicyHandlerTest,
        ApplyPolicySettings_DisabledSchemesWrongElementType) {
   // The policy expects string-valued elements. Give it booleans.
-  std::unique_ptr<base::ListValue> in(new base::ListValue);
-  in->AppendBoolean(false);
+  base::Value in(base::Value::Type::LIST);
+  in.Append(false);
   SetPolicy(key::kDisabledSchemes, std::move(in));
   ApplyPolicies();
 
@@ -148,8 +146,8 @@ TEST_F(URLBlacklistPolicyHandlerTest,
 TEST_F(URLBlacklistPolicyHandlerTest,
        ApplyPolicySettings_URLBlacklistWrongElementType) {
   // The policy expects string-valued elements. Give it booleans.
-  std::unique_ptr<base::ListValue> in(new base::ListValue);
-  in->AppendBoolean(false);
+  base::Value in(base::Value::Type::LIST);
+  in.Append(false);
   SetPolicy(key::kURLBlacklist, std::move(in));
   ApplyPolicies();
 
@@ -163,8 +161,8 @@ TEST_F(URLBlacklistPolicyHandlerTest,
 
 TEST_F(URLBlacklistPolicyHandlerTest,
        ApplyPolicySettings_DisabledSchemesSuccessful) {
-  std::unique_ptr<base::ListValue> in_disabled_schemes(new base::ListValue);
-  in_disabled_schemes->AppendString(kTestDisabledScheme);
+  base::Value in_disabled_schemes(base::Value::Type::LIST);
+  in_disabled_schemes.Append(kTestDisabledScheme);
   SetPolicy(key::kDisabledSchemes, std::move(in_disabled_schemes));
   ApplyPolicies();
 
@@ -181,8 +179,8 @@ TEST_F(URLBlacklistPolicyHandlerTest,
 
 TEST_F(URLBlacklistPolicyHandlerTest,
        ApplyPolicySettings_URLBlacklistSuccessful) {
-  std::unique_ptr<base::ListValue> in_url_blacklist(new base::ListValue);
-  in_url_blacklist->AppendString(kTestBlacklistValue);
+  base::Value in_url_blacklist(base::Value::Type::LIST);
+  in_url_blacklist.Append(kTestBlacklistValue);
   SetPolicy(key::kURLBlacklist, std::move(in_url_blacklist));
   ApplyPolicies();
 
@@ -198,12 +196,12 @@ TEST_F(URLBlacklistPolicyHandlerTest,
 }
 
 TEST_F(URLBlacklistPolicyHandlerTest, ApplyPolicySettings_MergeSuccessful) {
-  std::unique_ptr<base::ListValue> in_disabled_schemes(new base::ListValue);
-  in_disabled_schemes->AppendString(kTestDisabledScheme);
+  base::Value in_disabled_schemes(base::Value::Type::LIST);
+  in_disabled_schemes.Append(kTestDisabledScheme);
   SetPolicy(key::kDisabledSchemes, std::move(in_disabled_schemes));
 
-  std::unique_ptr<base::ListValue> in_url_blacklist(new base::ListValue);
-  in_url_blacklist->AppendString(kTestBlacklistValue);
+  base::Value in_url_blacklist(base::Value::Type::LIST);
+  in_url_blacklist.Append(kTestBlacklistValue);
   SetPolicy(key::kURLBlacklist, std::move(in_url_blacklist));
 
   ApplyPolicies();

components/policy/core/common/cloud/cloud_policy_manager_unittest.cc

@@ -91,37 +91,35 @@ void TestHarness::InstallEmptyPolicy() {}
 void TestHarness::InstallStringPolicy(const std::string& policy_name,
                                       const std::string& policy_value) {
   store_.policy_map_.Set(policy_name, policy_level(), policy_scope(),
-                         POLICY_SOURCE_CLOUD,
-                         std::make_unique<base::Value>(policy_value), nullptr);
+                         POLICY_SOURCE_CLOUD, base::Value(policy_value),
+                         nullptr);
 }
 
 void TestHarness::InstallIntegerPolicy(const std::string& policy_name,
                                        int policy_value) {
   store_.policy_map_.Set(policy_name, policy_level(), policy_scope(),
-                         POLICY_SOURCE_CLOUD,
-                         std::make_unique<base::Value>(policy_value), nullptr);
+                         POLICY_SOURCE_CLOUD, base::Value(policy_value),
+                         nullptr);
 }
 
 void TestHarness::InstallBooleanPolicy(const std::string& policy_name,
                                        bool policy_value) {
   store_.policy_map_.Set(policy_name, policy_level(), policy_scope(),
-                         POLICY_SOURCE_CLOUD,
-                         std::make_unique<base::Value>(policy_value), nullptr);
+                         POLICY_SOURCE_CLOUD, base::Value(policy_value),
+                         nullptr);
 }
 
 void TestHarness::InstallStringListPolicy(const std::string& policy_name,
                                           const base::ListValue* policy_value) {
   store_.policy_map_.Set(policy_name, policy_level(), policy_scope(),
-                         POLICY_SOURCE_CLOUD, policy_value->CreateDeepCopy(),
-                         nullptr);
+                         POLICY_SOURCE_CLOUD, policy_value->Clone(), nullptr);
 }
 
 void TestHarness::InstallDictionaryPolicy(
     const std::string& policy_name,
     const base::DictionaryValue* policy_value) {
   store_.policy_map_.Set(policy_name, policy_level(), policy_scope(),
-                         POLICY_SOURCE_CLOUD, policy_value->CreateDeepCopy(),
-                         nullptr);
+                         POLICY_SOURCE_CLOUD, policy_value->Clone(), nullptr);
 }
 
 // static
@@ -175,8 +173,7 @@ class CloudPolicyManagerTest : public testing::Test {
   void SetUp() override {
     // Set up a policy map for testing.
     policy_map_.Set("key", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-                    POLICY_SOURCE_CLOUD, std::make_unique<base::Value>("value"),
-                    nullptr);
+                    POLICY_SOURCE_CLOUD, base::Value("value"), nullptr);
     expected_bundle_.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .CopyFrom(policy_map_);
 

components/policy/core/common/cloud/machine_level_user_cloud_policy_store_unittest.cc

@@ -46,8 +46,8 @@ class MachineLevelUserCloudPolicyStoreTest : public ::testing::Test {
   void SetExpectedPolicyMap(PolicySource source) {
     expected_policy_map_.Clear();
     expected_policy_map_.Set("SearchSuggestEnabled", POLICY_LEVEL_MANDATORY,
-                             POLICY_SCOPE_MACHINE, source,
-                             std::make_unique<base::Value>(false), nullptr);
+                             POLICY_SCOPE_MACHINE, source, base::Value(false),
+                             nullptr);
   }
 
   std::unique_ptr<MachineLevelUserCloudPolicyStore> CreateStore(
@@ -255,7 +255,7 @@ TEST_F(MachineLevelUserCloudPolicyStoreTest, LoadRecentExternalPolicies) {
   PolicyMap expected_updater_policy_map;
   expected_updater_policy_map.Set(
       "SearchSuggestEnabled", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-      POLICY_SOURCE_CLOUD, std::make_unique<base::Value>(true), nullptr);
+      POLICY_SOURCE_CLOUD, base::Value(true), nullptr);
 
   ASSERT_TRUE(loader->policy());
   EXPECT_TRUE(expected_updater_policy_map.Equals(loader->policy_map()));
@@ -287,7 +287,7 @@ TEST_F(MachineLevelUserCloudPolicyStoreTest, LoadExternalOnlyPolicies) {
   PolicyMap expected_updater_policy_map;
   expected_updater_policy_map.Set(
       "SearchSuggestEnabled", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-      POLICY_SOURCE_CLOUD, std::make_unique<base::Value>(true), nullptr);
+      POLICY_SOURCE_CLOUD, base::Value(true), nullptr);
 
   ASSERT_TRUE(loader->policy());
   EXPECT_TRUE(expected_updater_policy_map.Equals(loader->policy_map()));

components/policy/core/common/policy_proto_decoders.cc

@@ -124,7 +124,7 @@ void DecodeProtoFields(
       continue;
 
     map->Set(access->policy_key, level, scope, source,
-             base::Value::ToUniquePtrValue(DecodeBooleanProto(proto)), nullptr);
+             DecodeBooleanProto(proto), nullptr);
   }
 
   for (const IntegerPolicyAccess* access = &kIntegerPolicyAccess[0];
@@ -138,8 +138,7 @@ void DecodeProtoFields(
 
     std::string error;
     map->Set(access->policy_key, level, scope, source,
-             base::Value::ToUniquePtrValue(DecodeIntegerProto(proto, &error)),
-             nullptr);
+             DecodeIntegerProto(proto, &error), nullptr);
     if (!error.empty())
       map->AddError(access->policy_key, error);
   }
@@ -164,8 +163,7 @@ void DecodeProtoFields(
                                                     access->policy_key)
             : nullptr;
 
-    map->Set(access->policy_key, level, scope, source,
-             base::Value::ToUniquePtrValue(std::move(value)),
+    map->Set(access->policy_key, level, scope, source, std::move(value),
              std::move(external_data_fetcher));
     if (!error.empty())
       map->AddError(access->policy_key, error);
@@ -181,8 +179,7 @@ void DecodeProtoFields(
       continue;
 
     map->Set(access->policy_key, level, scope, source,
-             base::Value::ToUniquePtrValue(DecodeStringListProto(proto)),
-             nullptr);
+             DecodeStringListProto(proto), nullptr);
   }
 }