Convert Pass()→std::move() in //chrome

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 <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/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 149 matching lines @@
       SupervisedUserRefreshTokenFetcher::Create(
           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(
-      profile->GetPrefs(),
-      token_fetcher.Pass(),
-      supervised_user_sync_service,
-      supervised_user_shared_settings_service));
+      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) {
-  return new SupervisedUserRegistrationUtilityImpl(prefs,
-                                                   token_fetcher.Pass(),
-                                                   service,
-                                                   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,
     SupervisedUserSyncService* service,
     SupervisedUserSharedSettingsService* shared_settings_service)
     : prefs_(prefs),
-      token_fetcher_(token_fetcher.Pass()),
+      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) {
   supervised_user_sync_service_->AddObserver(this);
 }
 
 SupervisedUserRegistrationUtilityImpl::
@@ skipping 183 matching lines @@
           pending_supervised_user_id_);
     }
   }
 
   if (run_callback)
     callback_.Run(error, pending_supervised_user_token_);
   callback_.Reset();
 }
 
 } // namespace