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

chrome/browser/chromeos/login/managed/locally_managed_user_creation_screen.cc

 // Copyright (c) 2013 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/locally_managed_user_creation_screen.h"
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "base/rand_util.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/camera_detector.h"
 #include "chrome/browser/chromeos/login/auth/key.h"
 #include "chrome/browser/chromeos/login/auth/user_context.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/managed/managed_user_creation_controller.h"
 #include "chrome/browser/chromeos/login/managed/managed_user_creation_controller_new.h"
 #include "chrome/browser/chromeos/login/managed/managed_user_creation_controller_old.h"
 #include "chrome/browser/chromeos/login/managed/supervised_user_authentication.h"
 #include "chrome/browser/chromeos/login/screens/error_screen.h"
 #include "chrome/browser/chromeos/login/screens/screen_observer.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_manager.h"
 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
-#include "chrome/browser/managed_mode/managed_user_constants.h"
-#include "chrome/browser/managed_mode/managed_user_shared_settings_service.h"
-#include "chrome/browser/managed_mode/managed_user_shared_settings_service_factory.h"
-#include "chrome/browser/managed_mode/managed_user_sync_service.h"
-#include "chrome/browser/managed_mode/managed_user_sync_service_factory.h"
+#include "chrome/browser/supervised_user/supervised_user_constants.h"
+#include "chrome/browser/supervised_user/supervised_user_shared_settings_service.h"
+#include "chrome/browser/supervised_user/supervised_user_shared_settings_service_factory.h"
+#include "chrome/browser/supervised_user/supervised_user_sync_service.h"
+#include "chrome/browser/supervised_user/supervised_user_sync_service_factory.h"
 #include "chromeos/network/network_state.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/generated_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace chromeos {
 
 namespace {
@@ skipping 192 matching lines @@
     LOG(ERROR) << "Can not import non-existing user " << user_id;
     return;
   }
   base::string16 display_name;
   std::string master_key;
   std::string signature_key;
   std::string encryption_key;
   std::string avatar;
   bool exists;
   int avatar_index = ManagedUserCreationController::kDummyAvatarIndex;
-  user_info->GetString(ManagedUserSyncService::kName, &display_name);
-  user_info->GetString(ManagedUserSyncService::kMasterKey, &master_key);
-  user_info->GetString(ManagedUserSyncService::kPasswordSignatureKey,
+  user_info->GetString(SupervisedUserSyncService::kName, &display_name);
+  user_info->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
+  user_info->GetString(SupervisedUserSyncService::kPasswordSignatureKey,
                        &signature_key);
-  user_info->GetString(ManagedUserSyncService::kPasswordEncryptionKey,
+  user_info->GetString(SupervisedUserSyncService::kPasswordEncryptionKey,
                        &encryption_key);
-  user_info->GetString(ManagedUserSyncService::kChromeOsAvatar, &avatar);
+  user_info->GetString(SupervisedUserSyncService::kChromeOsAvatar, &avatar);
   user_info->GetBoolean(kUserExists, &exists);
 
   // We should not get here with existing user selected, so just display error.
   if (exists) {
     actor_->ShowErrorPage(
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR_TITLE),
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR),
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR_BUTTON));
     return;
   }
 
-  ManagedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
+  SupervisedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
 
   const base::DictionaryValue* password_data = NULL;
-  ManagedUserSharedSettingsService* shared_settings_service =
-      ManagedUserSharedSettingsServiceFactory::GetForBrowserContext(
+  SupervisedUserSharedSettingsService* shared_settings_service =
+      SupervisedUserSharedSettingsServiceFactory::GetForBrowserContext(
           controller_->GetManagerProfile());
   const base::Value* value = shared_settings_service->GetValue(
-      user_id, managed_users::kChromeOSPasswordData);
+      user_id, supervised_users::kChromeOSPasswordData);
 
   bool password_right_here = value && value->GetAsDictionary(&password_data) &&
                              !password_data->empty();
 
   if (password_right_here) {
     controller_->StartImport(display_name,
                              avatar_index,
                              user_id,
                              master_key,
                              password_data,
@@ skipping 15 matching lines @@
   base::DictionaryValue* user_info;
   if (!existing_users_->GetDictionary(user_id, &user_info)) {
     LOG(ERROR) << "Can not import non-existing user " << user_id;
     return;
   }
   base::string16 display_name;
   std::string master_key;
   std::string avatar;
   bool exists;
   int avatar_index = ManagedUserCreationController::kDummyAvatarIndex;
-  user_info->GetString(ManagedUserSyncService::kName, &display_name);
-  user_info->GetString(ManagedUserSyncService::kMasterKey, &master_key);
-  user_info->GetString(ManagedUserSyncService::kChromeOsAvatar, &avatar);
+  user_info->GetString(SupervisedUserSyncService::kName, &display_name);
+  user_info->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
+  user_info->GetString(SupervisedUserSyncService::kChromeOsAvatar, &avatar);
   user_info->GetBoolean(kUserExists, &exists);
 
   // We should not get here with existing user selected, so just display error.
   if (exists) {
     actor_->ShowErrorPage(
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR_TITLE),
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR),
         l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR_BUTTON));
     return;
   }
 
-  ManagedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
+  SupervisedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
 
   controller_->StartImport(display_name,
                            password,
                            avatar_index,
                            user_id,
                            master_key);
 }
 
 void LocallyManagedUserCreationScreen::OnManagerLoginFailure() {
   if (actor_)
     actor_->ShowManagerPasswordError();
 }
 
 void LocallyManagedUserCreationScreen::OnManagerFullyAuthenticated(
     Profile* manager_profile) {
   DCHECK(controller_.get());
   // For manager user, move desktop to locked container so that windows created
   // during the user image picker step are below it.
   ash::Shell::GetInstance()->
       desktop_background_controller()->MoveDesktopToLockedContainer();
 
   controller_->SetManagerProfile(manager_profile);
   if (actor_)
     actor_->ShowUsernamePage();
 
   last_page_ = kNameOfNewUserParametersScreen;
   CHECK(!sync_service_);
-  sync_service_ = ManagedUserSyncServiceFactory::GetForProfile(manager_profile);
+  sync_service_ = SupervisedUserSyncServiceFactory::GetForProfile(
+      manager_profile);
   sync_service_->AddObserver(this);
-  OnManagedUsersChanged();
+  OnSupervisedUsersChanged();
 }
 
-void LocallyManagedUserCreationScreen::OnManagedUsersChanged() {
+void LocallyManagedUserCreationScreen::OnSupervisedUsersChanged() {
   CHECK(sync_service_);
-  sync_service_->GetManagedUsersAsync(
+  sync_service_->GetSupervisedUsersAsync(
       base::Bind(&LocallyManagedUserCreationScreen::OnGetManagedUsers,
                  weak_factory_.GetWeakPtr()));
 }
 
 void LocallyManagedUserCreationScreen::OnManagerCryptohomeAuthenticated() {
   if (actor_) {
     actor_->ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
             IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_AUTH_PROGRESS_MESSAGE));
   }
 }
@@ skipping 55 matching lines @@
 bool LocallyManagedUserCreationScreen::FindUserByDisplayName(
     const base::string16& display_name,
     std::string *out_id) const {
   if (!existing_users_.get())
     return false;
   for (base::DictionaryValue::Iterator it(*existing_users_.get());
        !it.IsAtEnd(); it.Advance()) {
     const base::DictionaryValue* user_info =
         static_cast<const base::DictionaryValue*>(&it.value());
     base::string16 user_display_name;
-    if (user_info->GetString(ManagedUserSyncService::kName,
+    if (user_info->GetString(SupervisedUserSyncService::kName,
                              &user_display_name)) {
       if (display_name == user_display_name) {
         if (out_id)
           *out_id = it.key();
         return true;
       }
     }
   }
   return false;
 }
@@ skipping 50 matching lines @@
     // Copy that would be stored in this class.
     base::DictionaryValue* local_copy =
         static_cast<base::DictionaryValue*>(it.value().DeepCopy());
     // Copy that would be passed to WebUI. It has some extra values for
     // displaying, but does not contain sensitive data, such as master password.
     base::DictionaryValue* ui_copy =
         static_cast<base::DictionaryValue*>(new base::DictionaryValue());
 
     int avatar_index = ManagedUserCreationController::kDummyAvatarIndex;
     std::string chromeos_avatar;
-    if (local_copy->GetString(ManagedUserSyncService::kChromeOsAvatar,
+    if (local_copy->GetString(SupervisedUserSyncService::kChromeOsAvatar,
                               &chromeos_avatar) &&
         !chromeos_avatar.empty() &&
-        ManagedUserSyncService::GetAvatarIndex(
+        SupervisedUserSyncService::GetAvatarIndex(
             chromeos_avatar, &avatar_index)) {
       ui_copy->SetString(kAvatarURLKey, GetDefaultImageUrl(avatar_index));
     } else {
       int i = base::RandInt(kFirstDefaultImageIndex, kDefaultImagesCount - 1);
       local_copy->SetString(
-          ManagedUserSyncService::kChromeOsAvatar,
-          ManagedUserSyncService::BuildAvatarString(i));
+          SupervisedUserSyncService::kChromeOsAvatar,
+          SupervisedUserSyncService::BuildAvatarString(i));
       local_copy->SetBoolean(kRandomAvatarKey, true);
       ui_copy->SetString(kAvatarURLKey, GetDefaultImageUrl(i));
     }
 
     local_copy->SetBoolean(kUserExists, false);
     ui_copy->SetBoolean(kUserExists, false);
 
     base::string16 display_name;
-    local_copy->GetString(ManagedUserSyncService::kName, &display_name);
+    local_copy->GetString(SupervisedUserSyncService::kName, &display_name);
 
     if (supervised_user_manager->FindBySyncId(it.key())) {
       local_copy->SetBoolean(kUserExists, true);
       ui_copy->SetBoolean(kUserExists, true);
       local_copy->SetString(kUserConflict, kUserConflictImported);
       ui_copy->SetString(kUserConflict, kUserConflictImported);
     } else if (supervised_user_manager->FindByDisplayName(display_name)) {
       local_copy->SetBoolean(kUserExists, true);
       ui_copy->SetBoolean(kUserExists, true);
       local_copy->SetString(kUserConflict, kUserConflictName);
       ui_copy->SetString(kUserConflict, kUserConflictName);
     }
-    ui_copy->SetString(ManagedUserSyncService::kName, display_name);
+    ui_copy->SetString(SupervisedUserSyncService::kName, display_name);
 
     std::string signature_key;
     bool has_password =
-        local_copy->GetString(ManagedUserSyncService::kPasswordSignatureKey,
+        local_copy->GetString(SupervisedUserSyncService::kPasswordSignatureKey,
                               &signature_key) &&
         !signature_key.empty();
 
     ui_copy->SetBoolean(kUserNeedPassword, !has_password);
     ui_copy->SetString("id", it.key());
 
     existing_users_->Set(it.key(), local_copy);
     ui_users->Append(ui_copy);
   }
   actor_->ShowExistingManagedUsers(ui_users.get());
@@ skipping 40 matching lines @@
     selected_image_ = User::kExternalImageIndex;
   } else {
     NOTREACHED() << "Unexpected image type: " << image_type;
   }
 }
 
 void LocallyManagedUserCreationScreen::OnImageAccepted() {
 }
 
 }  // namespace chromeos