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

components/policy/core/common/schema_registry_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/schema_registry.h"
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
 #include "components/policy/core/common/policy_namespace.h"
 #include "components/policy/core/common/schema.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Mock;
 using ::testing::_;
 
 namespace policy {
 
@@ skipping 115 matching lines @@
 
   registry.RemoveObserver(&observer);
 }
 
 TEST(SchemaRegistryTest, Combined) {
   std::string error;
   Schema schema = Schema::Parse(kTestSchema, &error);
   ASSERT_TRUE(schema.valid()) << error;
 
   MockSchemaRegistryObserver observer;
-  scoped_ptr<SchemaRegistry> registry1(new SchemaRegistry);
-  scoped_ptr<SchemaRegistry> registry2(new SchemaRegistry);
+  std::unique_ptr<SchemaRegistry> registry1(new SchemaRegistry);
+  std::unique_ptr<SchemaRegistry> registry2(new SchemaRegistry);
   CombinedSchemaRegistry combined;
   combined.AddObserver(&observer);
 
   EXPECT_CALL(observer, OnSchemaRegistryUpdated(_)).Times(0);
   registry1->RegisterComponent(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "abc"),
                                schema);
   Mock::VerifyAndClearExpectations(&observer);
 
   // Starting to track a registry issues notifications when it comes with new
   // schemas.
@@ skipping 84 matching lines @@
   Mock::VerifyAndClearExpectations(&observer);
 
   EXPECT_CALL(observer, OnSchemaRegistryUpdated(false));
   registry2.reset();
   Mock::VerifyAndClearExpectations(&observer);
 
   combined.RemoveObserver(&observer);
 }
 
 TEST(SchemaRegistryTest, ForwardingSchemaRegistry) {
-  scoped_ptr<SchemaRegistry> registry(new SchemaRegistry);
+  std::unique_ptr<SchemaRegistry> registry(new SchemaRegistry);
   ForwardingSchemaRegistry forwarding(registry.get());
   MockSchemaRegistryObserver observer;
   forwarding.AddObserver(&observer);
 
   EXPECT_FALSE(registry->IsReady());
   EXPECT_FALSE(forwarding.IsReady());
   // They always have the same SchemaMap.
   EXPECT_TRUE(SchemaMapEquals(registry->schema_map(), forwarding.schema_map()));
 
   EXPECT_CALL(observer, OnSchemaRegistryUpdated(true));
@@ skipping 38 matching lines @@
   // No notifications are expected in this case either.
   scoped_refptr<SchemaMap> schema_map = registry->schema_map();
   registry.reset();
   EXPECT_TRUE(SchemaMapEquals(schema_map, forwarding.schema_map()));
   Mock::VerifyAndClearExpectations(&observer);
 
   forwarding.RemoveObserver(&observer);
 }
 
 }  // namespace policy