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

chrome/browser/supervised_user/chromeos/manager_password_service.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/managed_mode/chromeos/manager_password_service.h"
+#include "chrome/browser/supervised_user/chromeos/manager_password_service.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/login/auth/key.h"
 #include "chrome/browser/chromeos/login/auth/user_context.h"
 #include "chrome/browser/chromeos/login/managed/locally_managed_user_constants.h"
 #include "chrome/browser/chromeos/login/managed/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
-#include "chrome/browser/managed_mode/managed_user_constants.h"
-#include "chrome/browser/managed_mode/managed_user_sync_service.h"
+#include "chrome/browser/supervised_user/supervised_user_constants.h"
+#include "chrome/browser/supervised_user/supervised_user_sync_service.h"
 
 namespace chromeos {
 
 ManagerPasswordService::ManagerPasswordService() : weak_ptr_factory_(this) {}
 
 ManagerPasswordService::~ManagerPasswordService() {}
 
 void ManagerPasswordService::Init(
     const std::string& user_id,
-    ManagedUserSyncService* user_service,
-    ManagedUserSharedSettingsService* shared_settings_service) {
+    SupervisedUserSyncService* user_service,
+    SupervisedUserSharedSettingsService* shared_settings_service) {
   user_id_ = user_id;
   user_service_ = user_service;
   settings_service_ = shared_settings_service;
   settings_service_subscription_ = settings_service_->Subscribe(
       base::Bind(&ManagerPasswordService::OnSharedSettingsChange,
                  weak_ptr_factory_.GetWeakPtr()));
 
   authenticator_ = new ExtendedAuthenticator(this);
 
   UserManager* user_manager = UserManager::Get();
 
   SupervisedUserManager* supervised_user_manager =
       user_manager->GetSupervisedUserManager();
 
   const UserList& users = user_manager->GetUsers();
 
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if ((*it)->GetType() != User::USER_TYPE_LOCALLY_MANAGED)
       continue;
     if (user_id != supervised_user_manager->GetManagerUserId((*it)->email()))
       continue;
     OnSharedSettingsChange(
         supervised_user_manager->GetUserSyncId((*it)->email()),
-        managed_users::kChromeOSPasswordData);
+        supervised_users::kChromeOSPasswordData);
   }
 }
 
 void ManagerPasswordService::OnSharedSettingsChange(
-    const std::string& mu_id,
+    const std::string& su_id,
     const std::string& key) {
-  if (key != managed_users::kChromeOSPasswordData)
+  if (key != supervised_users::kChromeOSPasswordData)
     return;
 
   SupervisedUserManager* supervised_user_manager =
       UserManager::Get()->GetSupervisedUserManager();
-  const User* user = supervised_user_manager->FindBySyncId(mu_id);
+  const User* user = supervised_user_manager->FindBySyncId(su_id);
   // No user on device.
   if (user == NULL)
     return;
 
-  const base::Value* value = settings_service_->GetValue(mu_id, key);
+  const base::Value* value = settings_service_->GetValue(su_id, key);
 
   if (value == NULL) {
     LOG(WARNING) << "Got empty value from sync.";
     return;
   }
   const base::DictionaryValue* dict;
   if (!value->GetAsDictionary(&dict)) {
     LOG(WARNING) << "Got non-dictionary value from sync.";
     return;
   }
 
   SupervisedUserAuthentication* auth =
       supervised_user_manager->GetAuthentication();
 
   if (!auth->NeedPasswordChange(user->email(), dict) &&
       !auth->HasIncompleteKey(user->email())) {
     return;
   }
   scoped_ptr<base::DictionaryValue> wrapper(dict->DeepCopy());
-  user_service_->GetManagedUsersAsync(
-      base::Bind(&ManagerPasswordService::GetManagedUsersCallback,
+  user_service_->GetSupervisedUsersAsync(
+      base::Bind(&ManagerPasswordService::GetSupervisedUsersCallback,
                  weak_ptr_factory_.GetWeakPtr(),
-                 mu_id,
+                 su_id,
                  user->email(),
                  Passed(&wrapper)));
 }
 
-void ManagerPasswordService::GetManagedUsersCallback(
-    const std::string& sync_mu_id,
+void ManagerPasswordService::GetSupervisedUsersCallback(
+    const std::string& sync_su_id,
     const std::string& user_id,
     scoped_ptr<base::DictionaryValue> password_data,
-    const base::DictionaryValue* managed_users) {
-  const base::DictionaryValue* managed_user = NULL;
-  if (!managed_users->GetDictionary(sync_mu_id, &managed_user))
+    const base::DictionaryValue* supervised_users) {
+  const base::DictionaryValue* supervised_user = NULL;
+  if (!supervised_users->GetDictionary(sync_su_id, &supervised_user))
     return;
   std::string master_key;
   std::string encryption_key;
   std::string signature_key;
-  if (!managed_user->GetString(ManagedUserSyncService::kMasterKey,
-                               &master_key)) {
+  if (!supervised_user->GetString(SupervisedUserSyncService::kMasterKey,
+                                  &master_key)) {
     LOG(WARNING) << "Can not apply password change to " << user_id
                  << ": no master key found";
     UMA_HISTOGRAM_ENUMERATION(
         "ManagedUsers.ChromeOS.PasswordChange",
         SupervisedUserAuthentication::PASSWORD_CHANGE_FAILED_NO_MASTER_KEY,
         SupervisedUserAuthentication::PASSWORD_CHANGE_RESULT_MAX_VALUE);
     return;
   }
 
-  if (!managed_user->GetString(ManagedUserSyncService::kPasswordSignatureKey,
-                               &signature_key) ||
-      !managed_user->GetString(ManagedUserSyncService::kPasswordEncryptionKey,
-                               &encryption_key)) {
+  if (!supervised_user->GetString(
+          SupervisedUserSyncService::kPasswordSignatureKey, &signature_key) ||
+      !supervised_user->GetString(
+          SupervisedUserSyncService::kPasswordEncryptionKey,
+          &encryption_key)) {
     LOG(WARNING) << "Can not apply password change to " << user_id
                  << ": no signature / encryption keys.";
     UMA_HISTOGRAM_ENUMERATION(
         "ManagedUsers.ChromeOS.PasswordChange",
         SupervisedUserAuthentication::PASSWORD_CHANGE_FAILED_NO_SIGNATURE_KEY,
         SupervisedUserAuthentication::PASSWORD_CHANGE_RESULT_MAX_VALUE);
     return;
   }
 
   UserContext manager_key(user_id);
@@ skipping 15 matching lines @@
                  << ": incomplete password data.";
     UMA_HISTOGRAM_ENUMERATION(
         "ManagedUsers.ChromeOS.PasswordChange",
         SupervisedUserAuthentication::PASSWORD_CHANGE_FAILED_NO_PASSWORD_DATA,
         SupervisedUserAuthentication::PASSWORD_CHANGE_RESULT_MAX_VALUE);
     return;
   }
 
   cryptohome::KeyDefinition new_key_definition(
       new_key,
-      kCryptohomeManagedUserKeyLabel,
+      kCryptohomeSupervisedUserKeyLabel,
       cryptohome::PRIV_AUTHORIZED_UPDATE || cryptohome::PRIV_MOUNT);
   new_key_definition.revision = revision;
 
   new_key_definition.encryption_key = encryption_key;
   new_key_definition.signature_key = signature_key;
 
   authenticator_->AddKey(manager_key,
                          new_key_definition,
                          true /* replace existing */,
                          base::Bind(&ManagerPasswordService::OnAddKeySuccess,
@@ skipping 60 matching lines @@
       base::Bind(&ManagerPasswordService::OnNewManagerKeySuccess,
                  weak_ptr_factory_.GetWeakPtr(),
                  new_master_key_context));
 }
 
 void ManagerPasswordService::OnNewManagerKeySuccess(
     const UserContext& master_key_context) {
   VLOG(1) << "Added new master key for " << master_key_context.GetUserID();
   authenticator_->RemoveKey(
       master_key_context,
-      kLegacyCryptohomeManagedUserKeyLabel,
-      base::Bind(&ManagerPasswordService::OnOldManagedUserKeyDeleted,
+      kLegacyCryptohomeSupervisedUserKeyLabel,
+      base::Bind(&ManagerPasswordService::OnOldSupervisedUserKeyDeleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  master_key_context));
 }
 
-void ManagerPasswordService::OnOldManagedUserKeyDeleted(
+void ManagerPasswordService::OnOldSupervisedUserKeyDeleted(
     const UserContext& master_key_context) {
-  VLOG(1) << "Removed old managed user key for "
+  VLOG(1) << "Removed old supervised user key for "
           << master_key_context.GetUserID();
   authenticator_->RemoveKey(
       master_key_context,
       kLegacyCryptohomeMasterKeyLabel,
       base::Bind(&ManagerPasswordService::OnOldManagerKeyDeleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  master_key_context));
 }
 
 void ManagerPasswordService::OnOldManagerKeyDeleted(
     const UserContext& master_key_context) {
   VLOG(1) << "Removed old master key for " << master_key_context.GetUserID();
 }
 
 void ManagerPasswordService::Shutdown() {
   settings_service_subscription_.reset();
 }
 
 }  // namespace chromeos