Convert //components/policy from scoped_ptr to std::unique_ptr

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>
@@ skipping 333 matching lines @@
 }
 
 RegistryTestHarness::~RegistryTestHarness() {}
 
 void RegistryTestHarness::SetUp() {}
 
 ConfigurationPolicyProvider* RegistryTestHarness::CreateProvider(
     SchemaRegistry* registry,
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   base::win::SetDomainStateForTesting(true);
-  scoped_ptr<AsyncPolicyLoader> loader(
+  std::unique_ptr<AsyncPolicyLoader> loader(
       new PolicyLoaderWin(task_runner, kTestPolicyKey, this));
   return new AsyncPolicyProvider(registry, std::move(loader));
 }
 
 void RegistryTestHarness::InstallEmptyPolicy() {}
 
 void RegistryTestHarness::InstallStringPolicy(
     const std::string& policy_name,
     const std::string& policy_value) {
   RegKey key(hive_, kTestPolicyKey, KEY_ALL_ACCESS);
@@ skipping 112 matching lines @@
                                    preg_parser::kPRegFileHeader,
                                    arraysize(preg_parser::kPRegFileHeader)));
 
   memset(&gpo_, 0, sizeof(GROUP_POLICY_OBJECT));
   gpo_.lpFileSysPath = const_cast<wchar_t*>(temp_dir_.path().value().c_str());
 }
 
 ConfigurationPolicyProvider* PRegTestHarness::CreateProvider(
     SchemaRegistry* registry,
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
-  scoped_ptr<AsyncPolicyLoader> loader(
+  std::unique_ptr<AsyncPolicyLoader> loader(
       new PolicyLoaderWin(task_runner, kTestPolicyKey, this));
   return new AsyncPolicyProvider(registry, std::move(loader));
 }
 
 void PRegTestHarness::InstallEmptyPolicy() {}
 
 void PRegTestHarness::InstallStringPolicy(const std::string& policy_name,
                                           const std::string& policy_value) {
   AppendStringToPRegFile(kTestPolicyKey, policy_name, policy_value);
 }
@@ skipping 244 matching lines @@
     memset(gpo, 0, sizeof(GROUP_POLICY_OBJECT));
     gpo->dwOptions = options;
     gpo->lpFileSysPath = const_cast<wchar_t*>(path.value().c_str());
     gpo->pNext = next;
     gpo->pPrev = prev;
   }
 
   bool Matches(const PolicyBundle& expected) {
     PolicyLoaderWin loader(loop_.task_runner(), kTestPolicyKey,
                            gpo_list_provider_);
-    scoped_ptr<PolicyBundle> loaded(
+    std::unique_ptr<PolicyBundle> loaded(
         loader.InitialLoad(schema_registry_.schema_map()));
     return loaded->Equals(expected);
   }
 
   void InstallRegistrySentinel() {
     RegKey hklm_key(HKEY_CURRENT_USER, kTestPolicyKey, KEY_ALL_ACCESS);
     ASSERT_TRUE(hklm_key.Valid());
     hklm_key.WriteValue(
         UTF8ToUTF16(test_keys::kKeyString).c_str(),
         UTF8ToUTF16("registry").c_str());
   }
 
   bool MatchesRegistrySentinel() {
     base::DictionaryValue expected_policy;
     expected_policy.SetString(test_keys::kKeyString, "registry");
     PolicyBundle expected;
     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                   POLICY_SOURCE_PLATFORM);
     return Matches(expected);
   }
 
   bool MatchesTestBundle() {
     base::DictionaryValue expected_policy;
     expected_policy.SetBoolean(test_keys::kKeyBoolean, true);
     expected_policy.SetString(test_keys::kKeyString, "GPO");
     expected_policy.SetInteger(test_keys::kKeyInteger, 42);
-    scoped_ptr<base::ListValue> list(new base::ListValue());
+    std::unique_ptr<base::ListValue> list(new base::ListValue());
     list->AppendString("GPO 1");
     list->AppendString("GPO 2");
     expected_policy.Set(test_keys::kKeyStringList, list.release());
     PolicyBundle expected;
     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM);
     return Matches(expected);
   }
 
@@ skipping 446 matching lines @@
   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("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       POLICY_SOURCE_PLATFORM, list.DeepCopy(), nullptr);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy