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

components/policy/core/common/policy_loader_win_unittest.cc

 // Copyright (c) 2012 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_loader_win.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <userenv.h>
 
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <iterator>
 #include <utility>
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "base/win/registry.h"
 #include "base/win/win_util.h"
@@ skipping 767 matching lines @@
   ASSERT_TRUE(hklm_key.Valid());
   hklm_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
                       UTF8ToUTF16("hklm").c_str());
   RegKey hkcu_key(HKEY_CURRENT_USER, kTestPolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(hkcu_key.Valid());
   hkcu_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
                       UTF8ToUTF16("hkcu").c_str());
 
   PolicyBundle expected;
   expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
-      .Set(test_keys::kKeyString,
-           POLICY_LEVEL_MANDATORY,
-           POLICY_SCOPE_MACHINE,
+      .Set(test_keys::kKeyString, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
            POLICY_SOURCE_PLATFORM,
-           new base::StringValue("hklm"),
-           NULL);
+           base::WrapUnique(new base::StringValue("hklm")), nullptr);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, Merge3rdPartyPolicies) {
   // Policy for the same extension will be provided at the 4 level/scope
   // combinations, to verify that they overlap as expected.
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "merge");
   ASSERT_TRUE(RegisterSchema(
       ns,
       "{"
@@ skipping 29 matching lines @@
                            kPathSuffix, kRecommended));
   policy.SetString("a", kUserRecommended);
   policy.SetString("b", kUserRecommended);
   policy.SetString("c", kUserRecommended);
   policy.SetString("d", kUserRecommended);
   EXPECT_TRUE(InstallValue(policy, HKEY_CURRENT_USER,
                            kPathSuffix, kRecommended));
 
   PolicyBundle expected;
   PolicyMap& expected_policy = expected.Get(ns);
-  expected_policy.Set("a",
-                      POLICY_LEVEL_MANDATORY,
-                      POLICY_SCOPE_MACHINE,
-                      POLICY_SOURCE_PLATFORM,
-                      new base::StringValue(kMachineMandatory),
-                      NULL);
-  expected_policy.Set("b",
-                      POLICY_LEVEL_MANDATORY,
-                      POLICY_SCOPE_USER,
-                      POLICY_SOURCE_PLATFORM,
-                      new base::StringValue(kUserMandatory),
-                      NULL);
-  expected_policy.Set("c",
-                      POLICY_LEVEL_RECOMMENDED,
-                      POLICY_SCOPE_MACHINE,
-                      POLICY_SOURCE_PLATFORM,
-                      new base::StringValue(kMachineRecommended),
-                      NULL);
-  expected_policy.Set("d",
-                      POLICY_LEVEL_RECOMMENDED,
-                      POLICY_SCOPE_USER,
-                      POLICY_SOURCE_PLATFORM,
-                      new base::StringValue(kUserRecommended),
-                      NULL);
+  expected_policy.Set(
+      "a", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM,
+      base::WrapUnique(new base::StringValue(kMachineMandatory)), nullptr);
+  expected_policy.Set(
+      "b", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER, POLICY_SOURCE_PLATFORM,
+      base::WrapUnique(new base::StringValue(kUserMandatory)), nullptr);
+  expected_policy.Set(
+      "c", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_MACHINE,
+      POLICY_SOURCE_PLATFORM,
+      base::WrapUnique(new base::StringValue(kMachineRecommended)), nullptr);
+  expected_policy.Set(
+      "d", POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER, POLICY_SOURCE_PLATFORM,
+      base::WrapUnique(new base::StringValue(kUserRecommended)), nullptr);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, LoadStringEncodedValues) {
   // Create a dictionary with all the types that can be stored encoded in a
   // string.
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "string");
   ASSERT_TRUE(RegisterSchema(
       ns,
       "{"
@@ skipping 325 matching lines @@
   policy.Set("url_list", list.DeepCopy());
   policy.SetString("alternative_browser_path", "c:\\legacy\\browser.exe");
   base::DictionaryValue root;
   root.Set(base::UTF16ToUTF8(kMandatory), policy.DeepCopy());
   root.SetString(kSchema, kIncompleteSchema);
   EXPECT_TRUE(InstallValue(root, HKEY_LOCAL_MACHINE,
                            kPathSuffix, base::ASCIIToUTF16(ns.component_id)));
 
   PolicyBundle expected;
   PolicyMap& expected_policy = expected.Get(ns);
-  expected_policy.Set("alternative_browser_path",
-                      POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                      POLICY_SOURCE_PLATFORM,
-                      new base::StringValue("c:\\legacy\\browser.exe"), NULL);
+  expected_policy.Set(
+      "alternative_browser_path", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+      POLICY_SOURCE_PLATFORM,
+      base::WrapUnique(new base::StringValue("c:\\legacy\\browser.exe")),
+      nullptr);
   expected_policy.Set("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                      POLICY_SOURCE_PLATFORM, list.DeepCopy(), nullptr);
+                      POLICY_SOURCE_PLATFORM, list.CreateDeepCopy(), nullptr);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy