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

chrome/browser/supervised_user/legacy/supervised_user_sync_service_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 <stdint.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
@@ skipping 72 matching lines @@
 }
 
 }  // namespace
 
 class SupervisedUserSyncServiceTest : public ::testing::Test {
  public:
   SupervisedUserSyncServiceTest();
   ~SupervisedUserSyncServiceTest() 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,
                             const std::string& avatar);
 
   PrefService* prefs() { return profile_.GetPrefs(); }
   SupervisedUserSyncService* service() { return service_; }
   MockChangeProcessor* change_processor() { return change_processor_; }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   TestingProfile profile_;
   SupervisedUserSyncService* service_;
 
   // Owned by the SupervisedUserSyncService.
   MockChangeProcessor* change_processor_;
 
   // A unique ID for creating "remote" Sync data.
   int64_t sync_data_id_;
 };
 
 SupervisedUserSyncServiceTest::SupervisedUserSyncServiceTest()
     : change_processor_(NULL),
       sync_data_id_(0) {
   service_ = SupervisedUserSyncServiceFactory::GetForProfile(&profile_);
 }
 
 SupervisedUserSyncServiceTest::~SupervisedUserSyncServiceTest() {}
 
-scoped_ptr<SyncChangeProcessor>
+std::unique_ptr<SyncChangeProcessor>
 SupervisedUserSyncServiceTest::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>
 SupervisedUserSyncServiceTest::CreateErrorFactory() {
-  return scoped_ptr<SyncErrorFactory>(new syncer::SyncErrorFactoryMock());
+  return std::unique_ptr<SyncErrorFactory>(new syncer::SyncErrorFactoryMock());
 }
 
 SyncData SupervisedUserSyncServiceTest::CreateRemoteData(
     const std::string& id,
     const std::string& name,
     const std::string& chrome_avatar) {
   ::sync_pb::EntitySpecifics specifics;
   specifics.mutable_managed_user()->set_id(id);
   specifics.mutable_managed_user()->set_name(name);
   specifics.mutable_managed_user()->set_acknowledged(true);
@@ skipping 218 matching lines @@
 
   EXPECT_FALSE(SupervisedUserSyncService::GetAvatarIndex(
       "chrome-avatar-index:x",
       &avatar));
 
   EXPECT_FALSE(SupervisedUserSyncService::GetAvatarIndex(
       "chromeos-avatar-index:5",
       &avatar));
 #endif
 }