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

components/policy/core/common/policy_loader_mac_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_mac.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 
 #include <utility>
 
@@ skipping 56 matching lines @@
                                 POLICY_SOURCE_PLATFORM) {}
 
 TestHarness::~TestHarness() {}
 
 void TestHarness::SetUp() {}
 
 ConfigurationPolicyProvider* TestHarness::CreateProvider(
     SchemaRegistry* registry,
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   prefs_ = new MockPreferences();
-  scoped_ptr<AsyncPolicyLoader> loader(
+  std::unique_ptr<AsyncPolicyLoader> loader(
       new PolicyLoaderMac(task_runner, base::FilePath(), prefs_));
   return new AsyncPolicyProvider(registry, std::move(loader));
 }
 
 void TestHarness::InstallEmptyPolicy() {}
 
 void TestHarness::InstallStringPolicy(const std::string& policy_name,
                                       const std::string& policy_value) {
   ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
   ScopedCFTypeRef<CFStringRef> value(base::SysUTF8ToCFStringRef(policy_value));
@@ skipping 50 matching lines @@
 // once the mac loader supports 3rd party policy. http://crbug.com/108995
 
 // Special test cases for some mac preferences details.
 class PolicyLoaderMacTest : public PolicyTestBase {
  protected:
   PolicyLoaderMacTest()
       : prefs_(new MockPreferences()) {}
 
   void SetUp() override {
     PolicyTestBase::SetUp();
-    scoped_ptr<AsyncPolicyLoader> loader(
+    std::unique_ptr<AsyncPolicyLoader> loader(
         new PolicyLoaderMac(loop_.task_runner(), base::FilePath(), prefs_));
     provider_.reset(
         new AsyncPolicyProvider(&schema_registry_, std::move(loader)));
     provider_->Init(&schema_registry_);
   }
 
   void TearDown() override {
     provider_->Shutdown();
     PolicyTestBase::TearDown();
   }
 
   MockPreferences* prefs_;
-  scoped_ptr<AsyncPolicyProvider> provider_;
+  std::unique_ptr<AsyncPolicyProvider> provider_;
 };
 
 TEST_F(PolicyLoaderMacTest, Invalid) {
   ScopedCFTypeRef<CFStringRef> name(
       base::SysUTF8ToCFStringRef(test_keys::kKeyString));
   const char buffer[] = "binary \xde\xad\xbe\xef data";
   ScopedCFTypeRef<CFDataRef> invalid_data(
       CFDataCreate(kCFAllocatorDefault,
                    reinterpret_cast<const UInt8 *>(buffer),
                    arraysize(buffer)));
@@ skipping 24 matching lines @@
       .Set(test_keys::kKeyString,
            POLICY_LEVEL_RECOMMENDED,
            POLICY_SCOPE_USER,
            POLICY_SOURCE_PLATFORM,
            new base::StringValue("string value"),
            NULL);
   EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
 }
 
 }  // namespace policy