Rename "managed (mode|user)" to "supervised user" (part 2)

chrome/browser/chromeos/login/managed/managed_user_creation_controller_new.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/chromeos/login/managed/managed_user_creation_controller_new.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 27 matching lines @@
 namespace {
 
 const int kUserCreationTimeoutSeconds = 30;  // 30 seconds.
 
 bool StoreManagedUserFiles(const std::string& token,
                            const base::FilePath& base_path) {
   if (!base::SysInfo::IsRunningOnChromeOS()) {
     // If running on desktop, cryptohome stub does not create home directory.
     base::CreateDirectory(base_path);
   }
-  base::FilePath token_file = base_path.Append(kManagedUserTokenFilename);
+  base::FilePath token_file = base_path.Append(kSupervisedUserTokenFilename);
   int bytes = base::WriteFile(token_file, token.c_str(), token.length());
   return bytes >= 0;
 }
 
 }  // namespace
 
 ManagedUserCreationControllerNew::ManagedUserCreationControllerNew(
     ManagedUserCreationControllerNew::StatusConsumer* consumer,
     const std::string& manager_id)
     : ManagedUserCreationController(consumer),
@@ skipping 86 matching lines @@
   VLOG(1) << "Starting supervised user creation";
   VLOG(1) << " Phase 1 : Prepare keys";
 
   SupervisedUserManager* manager =
       UserManager::Get()->GetSupervisedUserManager();
   manager->StartCreationTransaction(creation_context_->display_name);
 
   creation_context_->local_user_id = manager->GenerateUserId();
   if (creation_context_->creation_type == NEW_USER) {
     creation_context_->sync_user_id =
-        ManagedUserRegistrationUtility::GenerateNewManagedUserId();
+        SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId();
   }
 
   manager->SetCreationTransactionUserId(creation_context_->local_user_id);
 
   stage_ = TRANSACTION_STARTED;
 
   manager->CreateUserRecord(creation_context_->manager_id,
                             creation_context_->local_user_id,
                             creation_context_->sync_user_id,
                             creation_context_->display_name);
@@ skipping 90 matching lines @@
 void ManagedUserCreationControllerNew::OnMountSuccess(
     const std::string& mount_hash) {
   DCHECK(creation_context_);
   DCHECK_EQ(KEYS_GENERATED, stage_);
   VLOG(1) << " Phase 2.2 : Created home dir with master key";
 
   creation_context_->mount_hash = mount_hash;
 
   // Plain text password, hashed and salted with individual salt.
   // It can be used for mounting homedir, and can be replaced only when signed.
-  cryptohome::KeyDefinition password_key(creation_context_->salted_password,
-                                         kCryptohomeManagedUserKeyLabel,
-                                         kCryptohomeManagedUserKeyPrivileges);
+  cryptohome::KeyDefinition password_key(
+      creation_context_->salted_password,
+      kCryptohomeSupervisedUserKeyLabel,
+      kCryptohomeSupervisedUserKeyPrivileges);
   base::Base64Decode(creation_context_->encryption_key,
                      &password_key.encryption_key);
   base::Base64Decode(creation_context_->signature_key,
                      &password_key.signature_key);
 
   Key key(Key::KEY_TYPE_SALTED_PBKDF2_AES256_1234,
           std::string(),  // The salt is stored elsewhere.
           creation_context_->salted_master_key);
   key.SetLabel(kCryptohomeMasterKeyLabel);
   UserContext context(creation_context_->local_user_id);
@@ skipping 18 matching lines @@
   ProfileSyncService* sync_service =
       ProfileSyncServiceFactory::GetInstance()->GetForProfile(
           creation_context_->manager_profile);
   ProfileSyncService::SyncStatusSummary status =
       sync_service->QuerySyncStatusSummary();
 
   if (status == ProfileSyncService::DATATYPES_NOT_INITIALIZED)
     consumer_->OnLongCreationWarning();
 
   creation_context_->registration_utility =
-      ManagedUserRegistrationUtility::Create(
+      SupervisedUserRegistrationUtility::Create(
           creation_context_->manager_profile);
 
-  ManagedUserRegistrationInfo info(creation_context_->display_name,
-                                   creation_context_->avatar_index);
+  SupervisedUserRegistrationInfo info(creation_context_->display_name,
+                                      creation_context_->avatar_index);
   info.master_key = creation_context_->master_key;
   info.password_signature_key = creation_context_->signature_key;
   info.password_encryption_key = creation_context_->encryption_key;
 
   info.password_data.MergeDictionary(&creation_context_->password_data);
 
   // Registration utility will update user data if user already exist.
   creation_context_->registration_utility->Register(
       creation_context_->sync_user_id,
       info,
@@ skipping 70 matching lines @@
   creation_context_->registration_utility.reset();
   chrome::AttemptUserExit();
 }
 
 std::string ManagedUserCreationControllerNew::GetManagedUserId() {
   DCHECK(creation_context_);
   return creation_context_->local_user_id;
 }
 
 }  // namespace chromeos