Use std::unique_ptr to express ownership of base::Value in PolicyMap::Entry

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/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "components/policy/core/common/external_data_manager.h"
 #include "components/policy/core/common/policy_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 namespace {
 
 // Dummy policy names.
 const char kTestPolicyName1[] = "policy.test.1";
 const char kTestPolicyName2[] = "policy.test.2";
 const char kTestPolicyName3[] = "policy.test.3";
 const char kTestPolicyName4[] = "policy.test.4";
 const char kTestPolicyName5[] = "policy.test.5";
 const char kTestPolicyName6[] = "policy.test.6";
 const char kTestPolicyName7[] = "policy.test.7";
 const char kTestPolicyName8[] = "policy.test.8";
 
 // Utility functions for the tests.
-void SetPolicy(PolicyMap* map, const char* name, base::Value* value) {
+void SetPolicy(PolicyMap* map,
+               const char* name,
+               std::unique_ptr<base::Value> value) {
   map->Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
-           value, nullptr);
+           std::move(value), nullptr);
 }
 
 void SetPolicy(PolicyMap* map,
                const char* name,
-               ExternalDataFetcher* external_data_fetcher) {
+               std::unique_ptr<ExternalDataFetcher> external_data_fetcher) {
   map->Set(name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_CLOUD,
-           NULL, external_data_fetcher);
+           nullptr, std::move(external_data_fetcher));
 }
 
 }  // namespace
 
 class PolicyMapTest : public testing::Test {
  protected:
   std::unique_ptr<ExternalDataFetcher> CreateExternalDataFetcher(
       const std::string& policy) const;
 };
 
 std::unique_ptr<ExternalDataFetcher> PolicyMapTest::CreateExternalDataFetcher(
     const std::string& policy) const {
   return base::WrapUnique(
       new ExternalDataFetcher(base::WeakPtr<ExternalDataManager>(), policy));
 }
 
 TEST_F(PolicyMapTest, SetAndGet) {
   PolicyMap map;
-  SetPolicy(&map, kTestPolicyName1, new base::StringValue("aaa"));
+  SetPolicy(&map, kTestPolicyName1,
+            base::WrapUnique(new base::StringValue("aaa")));
   base::StringValue expected("aaa");
   EXPECT_TRUE(expected.Equals(map.GetValue(kTestPolicyName1)));
-  SetPolicy(&map, kTestPolicyName1, new base::StringValue("bbb"));
+  SetPolicy(&map, kTestPolicyName1,
+            base::WrapUnique(new base::StringValue("bbb")));
   base::StringValue expected_b("bbb");
   EXPECT_TRUE(expected_b.Equals(map.GetValue(kTestPolicyName1)));
-  SetPolicy(&map, kTestPolicyName1,
-            CreateExternalDataFetcher("dummy").release());
+  SetPolicy(&map, kTestPolicyName1, CreateExternalDataFetcher("dummy"));
   EXPECT_FALSE(map.GetValue(kTestPolicyName1));
   const PolicyMap::Entry* entry = map.Get(kTestPolicyName1);
   ASSERT_TRUE(entry != NULL);
   EXPECT_EQ(POLICY_LEVEL_MANDATORY, entry->level);
   EXPECT_EQ(POLICY_SCOPE_USER, entry->scope);
   EXPECT_EQ(POLICY_SOURCE_CLOUD, entry->source);
-  EXPECT_TRUE(ExternalDataFetcher::Equals(
-      entry->external_data_fetcher, CreateExternalDataFetcher("dummy").get()));
+  EXPECT_TRUE(
+      ExternalDataFetcher::Equals(entry->external_data_fetcher.get(),
+                                  CreateExternalDataFetcher("dummy").get()));
   map.Set(kTestPolicyName1, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
           POLICY_SOURCE_ENTERPRISE_DEFAULT, nullptr, nullptr);
   EXPECT_FALSE(map.GetValue(kTestPolicyName1));
   entry = map.Get(kTestPolicyName1);
   ASSERT_TRUE(entry != NULL);
   EXPECT_EQ(POLICY_LEVEL_RECOMMENDED, entry->level);
   EXPECT_EQ(POLICY_SCOPE_MACHINE, entry->scope);
   EXPECT_EQ(POLICY_SOURCE_ENTERPRISE_DEFAULT, entry->source);
   EXPECT_FALSE(entry->external_data_fetcher);
 }
 
 TEST_F(PolicyMapTest, Equals) {
   PolicyMap a;
-  SetPolicy(&a, kTestPolicyName1, new base::StringValue("aaa"));
+  SetPolicy(&a, kTestPolicyName1,
+            base::WrapUnique(new base::StringValue("aaa")));
   PolicyMap a2;
-  SetPolicy(&a2, kTestPolicyName1, new base::StringValue("aaa"));
+  SetPolicy(&a2, kTestPolicyName1,
+            base::WrapUnique(new base::StringValue("aaa")));
   PolicyMap b;
-  SetPolicy(&b, kTestPolicyName1, new base::StringValue("bbb"));
+  SetPolicy(&b, kTestPolicyName1,
+            base::WrapUnique(new base::StringValue("bbb")));
   PolicyMap c;
-  SetPolicy(&c, kTestPolicyName1, new base::StringValue("aaa"));
-  SetPolicy(&c, kTestPolicyName2, new base::FundamentalValue(true));
+  SetPolicy(&c, kTestPolicyName1,
+            base::WrapUnique(new base::StringValue("aaa")));
+  SetPolicy(&c, kTestPolicyName2,
+            base::WrapUnique(new base::FundamentalValue(true)));
   PolicyMap d;
-  SetPolicy(&d, kTestPolicyName1,
-            CreateExternalDataFetcher("ddd").release());
+  SetPolicy(&d, kTestPolicyName1, CreateExternalDataFetcher("ddd"));
   PolicyMap d2;
-  SetPolicy(&d2, kTestPolicyName1,
-            CreateExternalDataFetcher("ddd").release());
+  SetPolicy(&d2, kTestPolicyName1, CreateExternalDataFetcher("ddd"));
   PolicyMap e;
-  SetPolicy(&e, kTestPolicyName1,
-            CreateExternalDataFetcher("eee").release());
+  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));
   EXPECT_FALSE(b.Equals(a));
   EXPECT_FALSE(b.Equals(c));
   EXPECT_FALSE(b.Equals(d));
   EXPECT_FALSE(b.Equals(e));
   EXPECT_FALSE(c.Equals(a));
   EXPECT_FALSE(c.Equals(b));
@@ skipping 14 matching lines @@
   PolicyMap empty1;
   PolicyMap empty2;
   EXPECT_TRUE(empty1.Equals(empty2));
   EXPECT_TRUE(empty2.Equals(empty1));
   EXPECT_FALSE(empty1.Equals(a));
   EXPECT_FALSE(a.Equals(empty1));
 }
 
 TEST_F(PolicyMapTest, Swap) {
   PolicyMap a;
-  SetPolicy(&a, kTestPolicyName1, new base::StringValue("aaa"));
-  SetPolicy(&a, kTestPolicyName2,
-            CreateExternalDataFetcher("dummy").release());
+  SetPolicy(&a, kTestPolicyName1,
+            base::WrapUnique(new base::StringValue("aaa")));
+  SetPolicy(&a, kTestPolicyName2, CreateExternalDataFetcher("dummy"));
   PolicyMap b;
-  SetPolicy(&b, kTestPolicyName1, new base::StringValue("bbb"));
-  SetPolicy(&b, kTestPolicyName3, new base::FundamentalValue(true));
+  SetPolicy(&b, kTestPolicyName1,
+            base::WrapUnique(new base::StringValue("bbb")));
+  SetPolicy(&b, kTestPolicyName3,
+            base::WrapUnique(new base::FundamentalValue(true)));
 
   a.Swap(&b);
   base::StringValue expected("bbb");
   EXPECT_TRUE(expected.Equals(a.GetValue(kTestPolicyName1)));
   base::FundamentalValue 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));
+  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,
+  a.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD,
-        new base::StringValue("google.com"),
-        NULL);
-  a.Set(kTestPolicyName2,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new base::StringValue("google.com")), nullptr);
+  a.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+        POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(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,
-        new base::FundamentalValue(true),
-        NULL);
-  a.Set(kTestPolicyName3,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_ENTERPRISE_DEFAULT,
-        NULL, CreateExternalDataFetcher("a").release());
-  a.Set(kTestPolicyName4,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_USER,
+        base::WrapUnique(new base::FundamentalValue(false)), nullptr);
+  a.Set(kTestPolicyName5, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(false),
-        NULL);
-  a.Set(kTestPolicyName5,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD,
-        new base::StringValue("google.com/q={x}"),
-        NULL);
+        base::WrapUnique(new base::StringValue("google.com/q={x}")), nullptr);
 
   PolicyMap b;
-  b.Set(kTestPolicyName1,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+  b.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
-        new base::StringValue("chromium.org"),
-        NULL);
-  b.Set(kTestPolicyName2,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new base::StringValue("chromium.org")), nullptr);
+  b.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(false),
-        NULL);
-  b.Set(kTestPolicyName3,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD,
-        NULL, CreateExternalDataFetcher("b").release());
-  b.Set(kTestPolicyName4,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new base::FundamentalValue(false)), nullptr);
+  b.Set(kTestPolicyName3, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+        POLICY_SOURCE_CLOUD, nullptr, CreateExternalDataFetcher("b"));
+  b.Set(kTestPolicyName4, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE,
-        new base::FundamentalValue(true),
-        NULL);
-  b.Set(kTestPolicyName5,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new base::FundamentalValue(true)), nullptr);
+  b.Set(kTestPolicyName5, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PLATFORM,
-        new base::StringValue(std::string()),
-        NULL);
-  b.Set(kTestPolicyName6,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(true),
-        NULL);
+        base::WrapUnique(new base::StringValue(std::string())), nullptr);
+  b.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
+        POLICY_SOURCE_CLOUD, base::WrapUnique(new 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,
+  c.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
-        new base::StringValue("chromium.org"),
-        NULL);
+        base::WrapUnique(new base::StringValue("chromium.org")), nullptr);
   // |a| has precedence over |b|.
-  c.Set(kTestPolicyName2,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(true),
-        NULL);
-  c.Set(kTestPolicyName3,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_ENTERPRISE_DEFAULT,
-        NULL, CreateExternalDataFetcher("a").release());
+  c.Set(kTestPolicyName2, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+        POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(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,
+  c.Set(kTestPolicyName4, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE,
-        new base::FundamentalValue(true),
-        NULL);
+        base::WrapUnique(new base::FundamentalValue(true)), nullptr);
   // POLICY_LEVEL_MANDATORY over POLICY_LEVEL_RECOMMENDED.
-  c.Set(kTestPolicyName5,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+  c.Set(kTestPolicyName5, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PLATFORM,
-        new base::StringValue(std::string()),
-        NULL);
+        base::WrapUnique(new base::StringValue(std::string())), nullptr);
   // Merge new ones.
-  c.Set(kTestPolicyName6,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(true),
-        NULL);
+  c.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
+        POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)),
+        nullptr);
 
   EXPECT_TRUE(a.Equals(c));
 }
 
 TEST_F(PolicyMapTest, GetDifferingKeys) {
   PolicyMap a;
-  a.Set(kTestPolicyName1,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_USER,
+  a.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD,
-        new base::StringValue("google.com"),
-        NULL);
-  a.Set(kTestPolicyName2,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new 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::WrapUnique(new base::FundamentalValue(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,
-        NULL, CreateExternalDataFetcher("dummy").release());
-  a.Set(kTestPolicyName3,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new base::FundamentalValue(false)), nullptr);
+  a.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(true),
-        NULL);
-  a.Set(kTestPolicyName4,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD,
-        NULL, CreateExternalDataFetcher("a").release());
-  a.Set(kTestPolicyName5,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(false),
-        NULL);
-  a.Set(kTestPolicyName6,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_MACHINE,
-        POLICY_SOURCE_CLOUD,
-        new base::StringValue("google.com/q={x}"),
-        NULL);
-  a.Set(kTestPolicyName7,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(true),
-        NULL);
+        base::WrapUnique(new base::StringValue("google.com/q={x}")), nullptr);
+  a.Set(kTestPolicyName7, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+        POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(true)),
+        nullptr);
 
   PolicyMap b;
-  b.Set(kTestPolicyName1,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_USER,
+  b.Set(kTestPolicyName1, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD,
-        new base::StringValue("google.com"),
-        NULL);
-  b.Set(kTestPolicyName2,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new 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,
-        NULL, CreateExternalDataFetcher("dummy").release());
-  b.Set(kTestPolicyName3,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new base::FundamentalValue(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,
-        new base::FundamentalValue(false),
-        NULL);
-  b.Set(kTestPolicyName4,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_MACHINE,
+        base::WrapUnique(new base::FundamentalValue(false)), nullptr);
+  b.Set(kTestPolicyName6, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
         POLICY_SOURCE_CLOUD,
-        NULL, CreateExternalDataFetcher("b").release());
-  b.Set(kTestPolicyName5,
-        POLICY_LEVEL_MANDATORY,
-        POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(false),
-        NULL);
-  b.Set(kTestPolicyName6,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD,
-        new base::StringValue("google.com/q={x}"),
-        NULL);
-  b.Set(kTestPolicyName8,
-        POLICY_LEVEL_RECOMMENDED,
-        POLICY_SCOPE_USER,
-        POLICY_SOURCE_CLOUD,
-        new base::FundamentalValue(true),
-        NULL);
+        base::WrapUnique(new base::StringValue("google.com/q={x}")), nullptr);
+  b.Set(kTestPolicyName8, POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER,
+        POLICY_SOURCE_CLOUD, base::WrapUnique(new base::FundamentalValue(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 19 matching lines @@
   policies.SetBoolean("TestPolicy2", true);
   policies.SetInteger("TestPolicy3", -12321);
 
   PolicyMap loaded;
   loaded.LoadFrom(&policies,
                   POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_USER,
                   POLICY_SOURCE_PLATFORM);
 
   PolicyMap expected;
-  expected.Set("TestPolicy1",
-               POLICY_LEVEL_MANDATORY,
-               POLICY_SCOPE_USER,
+  expected.Set("TestPolicy1", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                POLICY_SOURCE_PLATFORM,
-               new base::StringValue("google.com"),
-               nullptr);
-  expected.Set("TestPolicy2",
-               POLICY_LEVEL_MANDATORY,
-               POLICY_SCOPE_USER,
+               base::WrapUnique(new base::StringValue("google.com")), nullptr);
+  expected.Set("TestPolicy2", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                POLICY_SOURCE_PLATFORM,
-               new base::FundamentalValue(true),
-               nullptr);
-  expected.Set("TestPolicy3",
-               POLICY_LEVEL_MANDATORY,
-               POLICY_SCOPE_USER,
+               base::WrapUnique(new base::FundamentalValue(true)), nullptr);
+  expected.Set("TestPolicy3", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                POLICY_SOURCE_PLATFORM,
-               new base::FundamentalValue(-12321),
-               nullptr);
+               base::WrapUnique(new base::FundamentalValue(-12321)), nullptr);
   EXPECT_TRUE(loaded.Equals(expected));
 }
 
 }  // namespace policy