Convert //chrome/browser/supervised_user from scoped_ptr to std::unique_ptr

chrome/browser/supervised_user/legacy/supervised_user_registration_utility_unittest.cc

 // Copyright 2014 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 "chrome/browser/supervised_user/legacy/supervised_user_registration_utility.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 79 matching lines @@
 }  // namespace
 
 class SupervisedUserRegistrationUtilityTest : public ::testing::Test {
  public:
   SupervisedUserRegistrationUtilityTest();
   ~SupervisedUserRegistrationUtilityTest() override;
 
   void TearDown() override;
 
  protected:
-  scoped_ptr<SyncChangeProcessor> CreateChangeProcessor();
-  scoped_ptr<SyncErrorFactory> CreateErrorFactory();
+  std::unique_ptr<SyncChangeProcessor> CreateChangeProcessor();
+  std::unique_ptr<SyncErrorFactory> CreateErrorFactory();
   SyncData CreateRemoteData(const std::string& id, const std::string& name);
 
   SyncMergeResult StartInitialSync();
 
   SupervisedUserRegistrationUtility::RegistrationCallback
       GetRegistrationCallback();
 
   SupervisedUserRegistrationUtility* GetRegistrationUtility();
 
   void Acknowledge();
@@ skipping 11 matching lines @@
 
  private:
   void OnSupervisedUserRegistered(const GoogleServiceAuthError& error,
                                   const std::string& token);
 
   base::MessageLoop message_loop_;
   base::RunLoop run_loop_;
   TestingProfile profile_;
   SupervisedUserSyncService* service_;
   SupervisedUserSharedSettingsService* shared_settings_service_;
-  scoped_ptr<SupervisedUserRegistrationUtility> registration_utility_;
+  std::unique_ptr<SupervisedUserRegistrationUtility> registration_utility_;
 
   // Owned by the SupervisedUserSyncService.
   MockChangeProcessor* change_processor_;
 
   // A unique ID for creating "remote" Sync data.
   int64_t sync_data_id_;
 
   // Whether OnSupervisedUserRegistered has been called.
   bool received_callback_;
 
@@ skipping 18 matching lines @@
 
 SupervisedUserRegistrationUtilityTest::
     ~SupervisedUserRegistrationUtilityTest() {
   EXPECT_FALSE(weak_ptr_factory_.HasWeakPtrs());
 }
 
 void SupervisedUserRegistrationUtilityTest::TearDown() {
   content::RunAllBlockingPoolTasksUntilIdle();
 }
 
-scoped_ptr<SyncChangeProcessor>
+std::unique_ptr<SyncChangeProcessor>
 SupervisedUserRegistrationUtilityTest::CreateChangeProcessor() {
   EXPECT_FALSE(change_processor_);
   change_processor_ = new MockChangeProcessor();
-  return scoped_ptr<SyncChangeProcessor>(change_processor_);
+  return std::unique_ptr<SyncChangeProcessor>(change_processor_);
 }
 
-scoped_ptr<SyncErrorFactory>
+std::unique_ptr<SyncErrorFactory>
 SupervisedUserRegistrationUtilityTest::CreateErrorFactory() {
-  return scoped_ptr<SyncErrorFactory>(new syncer::SyncErrorFactoryMock());
+  return std::unique_ptr<SyncErrorFactory>(new syncer::SyncErrorFactoryMock());
 }
 
 SyncMergeResult SupervisedUserRegistrationUtilityTest::StartInitialSync() {
   SyncDataList initial_sync_data;
   SyncMergeResult result =
       service()->MergeDataAndStartSyncing(SUPERVISED_USERS,
                                           initial_sync_data,
                                           CreateChangeProcessor(),
                                           CreateErrorFactory());
   EXPECT_FALSE(result.error().IsSet());
   return result;
 }
 
 SupervisedUserRegistrationUtility::RegistrationCallback
 SupervisedUserRegistrationUtilityTest::GetRegistrationCallback() {
   return base::Bind(
       &SupervisedUserRegistrationUtilityTest::OnSupervisedUserRegistered,
       weak_ptr_factory_.GetWeakPtr());
 }
 
 SupervisedUserRegistrationUtility*
 SupervisedUserRegistrationUtilityTest::GetRegistrationUtility() {
   if (registration_utility_.get())
     return registration_utility_.get();
 
-  scoped_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher(
+  std::unique_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher(
       new MockSupervisedUserRefreshTokenFetcher);
   registration_utility_.reset(SupervisedUserRegistrationUtility::CreateImpl(
       prefs(), std::move(token_fetcher), service(), shared_settings_service()));
   return registration_utility_.get();
 }
 
 void SupervisedUserRegistrationUtilityTest::Acknowledge() {
   SyncChangeList new_changes;
   for (const SyncChange& sync_change : change_processor()->changes()) {
     EXPECT_EQ(SyncChange::ACTION_ADD, sync_change.change_type());
@@ skipping 74 matching lines @@
       SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId(),
       SupervisedUserRegistrationInfo(base::ASCIIToUTF16("Mike"), 17),
       GetRegistrationCallback());
   EXPECT_EQ(1u, prefs()->GetDictionary(prefs::kSupervisedUsers)->size());
   service()->StopSyncing(SUPERVISED_USERS);
   EXPECT_EQ(0u, prefs()->GetDictionary(prefs::kSupervisedUsers)->size());
   EXPECT_TRUE(received_callback());
   EXPECT_EQ(GoogleServiceAuthError::REQUEST_CANCELED, error().state());
   EXPECT_EQ(std::string(), token());
 }