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/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);
   }
 }