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

chrome/browser/supervised_user/legacy/supervised_user_registration_utility.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 <memory>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/chrome_signin_client_factory.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_refresh_token_fetcher.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_shared_settings_service_factory.h"
@@ skipping 18 matching lines @@
 
 SupervisedUserRegistrationUtility* g_instance_for_tests = NULL;
 
 // Actual implementation of SupervisedUserRegistrationUtility.
 class SupervisedUserRegistrationUtilityImpl
     : public SupervisedUserRegistrationUtility,
       public SupervisedUserSyncServiceObserver {
  public:
   SupervisedUserRegistrationUtilityImpl(
       PrefService* prefs,
-      scoped_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher,
+      std::unique_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher,
       SupervisedUserSyncService* service,
       SupervisedUserSharedSettingsService* shared_settings_service);
 
   ~SupervisedUserRegistrationUtilityImpl() override;
 
   // Registers a new supervised user with the server. |supervised_user_id| is a
   // new unique ID for the new supervised user. If its value is the same as that
   // of one of the existing supervised users, then the same user will be created
   // on this machine (and if he has no avatar in sync, his avatar will be
   // updated). |info| contains necessary information like the display name of
@@ skipping 34 matching lines @@
 
   // Cancels any registration currently in progress, without calling the
   // callback or reporting an error.
   void CancelPendingRegistration();
 
   // SupervisedUserSharedSettingsUpdate acknowledgment callback for password
   // data in shared settings.
   void OnPasswordChangeAcknowledged(bool success);
 
   PrefService* prefs_;
-  scoped_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher_;
+  std::unique_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher_;
 
   // A |KeyedService| owned by the custodian profile.
   SupervisedUserSyncService* supervised_user_sync_service_;
 
   // A |KeyedService| owned by the custodian profile.
   SupervisedUserSharedSettingsService* supervised_user_shared_settings_service_;
 
   std::string pending_supervised_user_id_;
   std::string pending_supervised_user_token_;
   bool pending_supervised_user_acknowledged_;
   bool is_existing_supervised_user_;
   bool avatar_updated_;
   RegistrationCallback callback_;
-  scoped_ptr<SupervisedUserSharedSettingsUpdate> password_update_;
+  std::unique_ptr<SupervisedUserSharedSettingsUpdate> password_update_;
 
   base::WeakPtrFactory<SupervisedUserRegistrationUtilityImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SupervisedUserRegistrationUtilityImpl);
 };
 
 } // namespace
 
 SupervisedUserRegistrationInfo::SupervisedUserRegistrationInfo(
     const base::string16& name,
     int avatar_index)
     : avatar_index(avatar_index),
       name(name) {
 }
 
 SupervisedUserRegistrationInfo::~SupervisedUserRegistrationInfo() {}
 
 ScopedTestingSupervisedUserRegistrationUtility::
     ScopedTestingSupervisedUserRegistrationUtility(
         SupervisedUserRegistrationUtility* instance) {
   SupervisedUserRegistrationUtility::SetUtilityForTests(instance);
 }
 
 ScopedTestingSupervisedUserRegistrationUtility::
     ~ScopedTestingSupervisedUserRegistrationUtility() {
   SupervisedUserRegistrationUtility::SetUtilityForTests(NULL);
 }
 
 // static
-scoped_ptr<SupervisedUserRegistrationUtility>
+std::unique_ptr<SupervisedUserRegistrationUtility>
 SupervisedUserRegistrationUtility::Create(Profile* profile) {
   if (g_instance_for_tests) {
     SupervisedUserRegistrationUtility* result = g_instance_for_tests;
     g_instance_for_tests = NULL;
-    return make_scoped_ptr(result);
+    return base::WrapUnique(result);
   }
 
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetForProfile(profile);
   SigninClient* signin_client =
       ChromeSigninClientFactory::GetForProfile(profile);
   std::string signin_scoped_device_id =
       signin_client->GetSigninScopedDeviceId();
-  scoped_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher =
+  std::unique_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher =
       SupervisedUserRefreshTokenFetcher::Create(
-          token_service,
-          signin_manager->GetAuthenticatedAccountId(),
-          signin_scoped_device_id,
-          profile->GetRequestContext());
+          token_service, signin_manager->GetAuthenticatedAccountId(),
+          signin_scoped_device_id, profile->GetRequestContext());
   SupervisedUserSyncService* supervised_user_sync_service =
       SupervisedUserSyncServiceFactory::GetForProfile(profile);
   SupervisedUserSharedSettingsService* supervised_user_shared_settings_service =
       SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(profile);
-  return make_scoped_ptr(SupervisedUserRegistrationUtility::CreateImpl(
+  return base::WrapUnique(SupervisedUserRegistrationUtility::CreateImpl(
       profile->GetPrefs(), std::move(token_fetcher),
       supervised_user_sync_service, supervised_user_shared_settings_service));
 }
 
 // static
 std::string SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId() {
   std::string new_supervised_user_id;
   base::Base64Encode(base::RandBytesAsString(8), &new_supervised_user_id);
   return new_supervised_user_id;
 }
 
 // static
 void SupervisedUserRegistrationUtility::SetUtilityForTests(
     SupervisedUserRegistrationUtility* utility) {
   if (g_instance_for_tests)
     delete g_instance_for_tests;
   g_instance_for_tests = utility;
 }
 
 // static
 SupervisedUserRegistrationUtility*
 SupervisedUserRegistrationUtility::CreateImpl(
-      PrefService* prefs,
-      scoped_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher,
-      SupervisedUserSyncService* service,
-      SupervisedUserSharedSettingsService* shared_settings_service) {
+    PrefService* prefs,
+    std::unique_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher,
+    SupervisedUserSyncService* service,
+    SupervisedUserSharedSettingsService* shared_settings_service) {
   return new SupervisedUserRegistrationUtilityImpl(
       prefs, std::move(token_fetcher), service, shared_settings_service);
 }
 
 namespace {
 
 SupervisedUserRegistrationUtilityImpl::SupervisedUserRegistrationUtilityImpl(
     PrefService* prefs,
-    scoped_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher,
+    std::unique_ptr<SupervisedUserRefreshTokenFetcher> token_fetcher,
     SupervisedUserSyncService* service,
     SupervisedUserSharedSettingsService* shared_settings_service)
     : prefs_(prefs),
       token_fetcher_(std::move(token_fetcher)),
       supervised_user_sync_service_(service),
       supervised_user_shared_settings_service_(shared_settings_service),
       pending_supervised_user_acknowledged_(false),
       is_existing_supervised_user_(false),
       avatar_updated_(false),
       weak_ptr_factory_(this) {
@@ skipping 65 matching lines @@
 #if defined(OS_CHROMEOS)
   const char* kAvatarKey = supervised_users::kChromeOSAvatarIndex;
 #else
   const char* kAvatarKey = supervised_users::kChromeAvatarIndex;
 #endif
   supervised_user_shared_settings_service_->SetValue(
       pending_supervised_user_id_, kAvatarKey,
       base::FundamentalValue(info.avatar_index));
   if (need_password_update) {
     password_update_.reset(new SupervisedUserSharedSettingsUpdate(
-        supervised_user_shared_settings_service_,
-        pending_supervised_user_id_,
+        supervised_user_shared_settings_service_, pending_supervised_user_id_,
         supervised_users::kChromeOSPasswordData,
-        scoped_ptr<base::Value>(info.password_data.DeepCopy()),
-        base::Bind(
-            &SupervisedUserRegistrationUtilityImpl::
-                OnPasswordChangeAcknowledged,
-            weak_ptr_factory_.GetWeakPtr())));
+        std::unique_ptr<base::Value>(info.password_data.DeepCopy()),
+        base::Bind(&SupervisedUserRegistrationUtilityImpl::
+                       OnPasswordChangeAcknowledged,
+                   weak_ptr_factory_.GetWeakPtr())));
   }
 
   syncer::GetSessionName(
       content::BrowserThread::GetBlockingPool()
           ->GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN).get(),
       base::Bind(&SupervisedUserRegistrationUtilityImpl::FetchToken,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
@@ skipping 94 matching lines @@
           pending_supervised_user_id_);
     }
   }
 
   if (run_callback)
     callback_.Run(error, pending_supervised_user_token_);
   callback_.Reset();
 }
 
 } // namespace