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

chrome/browser/chromeos/login/supervised/supervised_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 "chrome/browser/chromeos/login/supervised/supervised_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/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/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/signin_specifics.h"
+#include "chrome/browser/chromeos/login/supervised/supervised_user_authentication.h"
+#include "chrome/browser/chromeos/login/supervised/supervised_user_creation_controller.h"
+#include "chrome/browser/chromeos/login/supervised/supervised_user_creation_controller_new.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/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/login/auth/key.h"
 #include "chromeos/login/auth/user_context.h"
@@ skipping 47 matching lines @@
                             std::string());
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 } // namespace
 
-LocallyManagedUserCreationScreen::LocallyManagedUserCreationScreen(
+SupervisedUserCreationScreen::SupervisedUserCreationScreen(
     ScreenObserver* observer,
-    LocallyManagedUserCreationScreenHandler* actor)
+    SupervisedUserCreationScreenHandler* actor)
     : WizardScreen(observer),
       weak_factory_(this),
       actor_(actor),
       on_error_screen_(false),
       last_page_(kNameOfIntroScreen),
       sync_service_(NULL),
       image_decoder_(NULL),
       apply_photo_after_decoding_(false),
       selected_image_(0) {
   DCHECK(actor_);
   if (actor_)
     actor_->SetDelegate(this);
 }
 
-LocallyManagedUserCreationScreen::~LocallyManagedUserCreationScreen() {
+SupervisedUserCreationScreen::~SupervisedUserCreationScreen() {
   CameraPresenceNotifier::GetInstance()->RemoveObserver(this);
   if (sync_service_)
     sync_service_->RemoveObserver(this);
   if (actor_)
     actor_->SetDelegate(NULL);
   if (image_decoder_.get())
     image_decoder_->set_delegate(NULL);
   NetworkPortalDetector::Get()->RemoveObserver(this);
 }
 
-void LocallyManagedUserCreationScreen::PrepareToShow() {
+void SupervisedUserCreationScreen::PrepareToShow() {
   if (actor_)
     actor_->PrepareToShow();
 }
 
-void LocallyManagedUserCreationScreen::Show() {
+void SupervisedUserCreationScreen::Show() {
   CameraPresenceNotifier::GetInstance()->AddObserver(this);
   if (actor_) {
     actor_->Show();
     // TODO(antrim) : temorary hack (until upcoming hackaton). Should be
     // removed once we have screens reworked.
     if (on_error_screen_)
       actor_->ShowPage(last_page_);
     else
       actor_->ShowIntroPage();
   }
 
   if (!on_error_screen_)
     NetworkPortalDetector::Get()->AddAndFireObserver(this);
   on_error_screen_ = false;
 }
 
-void LocallyManagedUserCreationScreen::OnPageSelected(const std::string& page) {
+void SupervisedUserCreationScreen::OnPageSelected(const std::string& page) {
   last_page_ = page;
 }
 
-void LocallyManagedUserCreationScreen::OnPortalDetectionCompleted(
+void SupervisedUserCreationScreen::OnPortalDetectionCompleted(
     const NetworkState* network,
     const NetworkPortalDetector::CaptivePortalState& state)  {
   if (state.status == NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE) {
     get_screen_observer()->HideErrorScreen(this);
   } else {
     on_error_screen_ = true;
     ErrorScreen* screen = get_screen_observer()->GetErrorScreen();
     ConfigureErrorScreen(screen, network, state.status);
-    screen->SetUIState(ErrorScreen::UI_STATE_LOCALLY_MANAGED);
+    screen->SetUIState(ErrorScreen::UI_STATE_SUPERVISED);
     get_screen_observer()->ShowErrorScreen();
   }
 }
 
-void LocallyManagedUserCreationScreen::
-    ShowManagerInconsistentStateErrorScreen() {
+void SupervisedUserCreationScreen::ShowManagerInconsistentStateErrorScreen() {
   if (!actor_)
     return;
   actor_->ShowErrorPage(
       l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_MANAGER_INCONSISTENT_STATE_TITLE),
       l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_MANAGER_INCONSISTENT_STATE),
       l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_MANAGER_INCONSISTENT_STATE_BUTTON));
 }
 
-void LocallyManagedUserCreationScreen::ShowInitialScreen() {
+void SupervisedUserCreationScreen::ShowInitialScreen() {
   if (actor_)
     actor_->ShowIntroPage();
 }
 
-void LocallyManagedUserCreationScreen::Hide() {
+void SupervisedUserCreationScreen::Hide() {
   CameraPresenceNotifier::GetInstance()->RemoveObserver(this);
   if (actor_)
     actor_->Hide();
   if (!on_error_screen_)
     NetworkPortalDetector::Get()->RemoveObserver(this);
 }
 
-std::string LocallyManagedUserCreationScreen::GetName() const {
-  return WizardController::kLocallyManagedUserCreationScreenName;
+std::string SupervisedUserCreationScreen::GetName() const {
+  return WizardController::kSupervisedUserCreationScreenName;
 }
 
-void LocallyManagedUserCreationScreen::AbortFlow() {
+void SupervisedUserCreationScreen::AbortFlow() {
   controller_->CancelCreation();
 }
 
-void LocallyManagedUserCreationScreen::FinishFlow() {
+void SupervisedUserCreationScreen::FinishFlow() {
   controller_->FinishCreation();
 }
 
-void LocallyManagedUserCreationScreen::AuthenticateManager(
+void SupervisedUserCreationScreen::AuthenticateManager(
     const std::string& manager_id,
     const std::string& manager_password) {
   // Make sure no two controllers exist at the same time.
   controller_.reset();
 
-  controller_.reset(new ManagedUserCreationControllerNew(this, manager_id));
+  controller_.reset(new SupervisedUserCreationControllerNew(this, manager_id));
 
   UserContext user_context(manager_id);
   user_context.SetKey(Key(manager_password));
   ExistingUserController::current_controller()->Login(user_context,
                                                       SigninSpecifics());
 }
 
-void LocallyManagedUserCreationScreen::CreateManagedUser(
+void SupervisedUserCreationScreen::CreateSupervisedUser(
     const base::string16& display_name,
-    const std::string& managed_user_password) {
+    const std::string& supervised_user_password) {
   DCHECK(controller_.get());
   int image;
   if (selected_image_ == User::kExternalImageIndex)
     // TODO(dzhioev): crbug/249660
-    image = ManagedUserCreationController::kDummyAvatarIndex;
+    image = SupervisedUserCreationController::kDummyAvatarIndex;
   else
     image = selected_image_;
-  controller_->StartCreation(display_name, managed_user_password, image);
+  controller_->StartCreation(display_name, supervised_user_password, image);
 }
 
-void LocallyManagedUserCreationScreen::ImportManagedUser(
+void SupervisedUserCreationScreen::ImportSupervisedUser(
     const std::string& user_id) {
   DCHECK(controller_.get());
   DCHECK(existing_users_.get());
   VLOG(1) << "Importing user " << user_id;
   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 signature_key;
   std::string encryption_key;
   std::string avatar;
   bool exists;
-  int avatar_index = ManagedUserCreationController::kDummyAvatarIndex;
+  int avatar_index = SupervisedUserCreationController::kDummyAvatarIndex;
   user_info->GetString(SupervisedUserSyncService::kName, &display_name);
   user_info->GetString(SupervisedUserSyncService::kMasterKey, &master_key);
   user_info->GetString(SupervisedUserSyncService::kPasswordSignatureKey,
                        &signature_key);
   user_info->GetString(SupervisedUserSyncService::kPasswordEncryptionKey,
                        &encryption_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.
@@ skipping 28 matching lines @@
                              password_data,
                              encryption_key,
                              signature_key);
   } else {
     NOTREACHED() << " Oops, no password";
   }
 }
 
 // TODO(antrim): Code duplication with previous method will be removed once
 // password sync is implemented.
-void LocallyManagedUserCreationScreen::ImportManagedUserWithPassword(
+void SupervisedUserCreationScreen::ImportSupervisedUserWithPassword(
     const std::string& user_id,
     const std::string& password) {
   DCHECK(controller_.get());
   DCHECK(existing_users_.get());
   VLOG(1) << "Importing user " << user_id;
   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;
+  int avatar_index = SupervisedUserCreationController::kDummyAvatarIndex;
   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;
   }
 
   SupervisedUserSyncService::GetAvatarIndex(avatar, &avatar_index);
 
   controller_->StartImport(display_name,
                            password,
                            avatar_index,
                            user_id,
                            master_key);
 }
 
-void LocallyManagedUserCreationScreen::OnManagerLoginFailure() {
+void SupervisedUserCreationScreen::OnManagerLoginFailure() {
   if (actor_)
     actor_->ShowManagerPasswordError();
 }
 
-void LocallyManagedUserCreationScreen::OnManagerFullyAuthenticated(
+void SupervisedUserCreationScreen::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_ = SupervisedUserSyncServiceFactory::GetForProfile(
       manager_profile);
   sync_service_->AddObserver(this);
   OnSupervisedUsersChanged();
 }
 
-void LocallyManagedUserCreationScreen::OnSupervisedUsersChanged() {
+void SupervisedUserCreationScreen::OnSupervisedUsersChanged() {
   CHECK(sync_service_);
   sync_service_->GetSupervisedUsersAsync(
-      base::Bind(&LocallyManagedUserCreationScreen::OnGetManagedUsers,
+      base::Bind(&SupervisedUserCreationScreen::OnGetSupervisedUsers,
                  weak_factory_.GetWeakPtr()));
 }
 
-void LocallyManagedUserCreationScreen::OnManagerCryptohomeAuthenticated() {
+void SupervisedUserCreationScreen::OnManagerCryptohomeAuthenticated() {
   if (actor_) {
     actor_->ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
-            IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_AUTH_PROGRESS_MESSAGE));
+        IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_AUTH_PROGRESS_MESSAGE));
   }
 }
 
-void LocallyManagedUserCreationScreen::OnActorDestroyed(
-    LocallyManagedUserCreationScreenHandler* actor) {
+void SupervisedUserCreationScreen::OnActorDestroyed(
+    SupervisedUserCreationScreenHandler* actor) {
   if (actor_ == actor)
     actor_ = NULL;
 }
 
-void LocallyManagedUserCreationScreen::OnCreationError(
-    ManagedUserCreationController::ErrorCode code) {
+void SupervisedUserCreationScreen::OnCreationError(
+    SupervisedUserCreationController::ErrorCode code) {
   base::string16 title;
   base::string16 message;
   base::string16 button;
   // TODO(antrim) : find out which errors do we really have.
   // We might reuse some error messages from ordinary user flow.
   switch (code) {
-    case ManagedUserCreationController::CRYPTOHOME_NO_MOUNT:
-    case ManagedUserCreationController::CRYPTOHOME_FAILED_MOUNT:
-    case ManagedUserCreationController::CRYPTOHOME_FAILED_TPM:
+    case SupervisedUserCreationController::CRYPTOHOME_NO_MOUNT:
+    case SupervisedUserCreationController::CRYPTOHOME_FAILED_MOUNT:
+    case SupervisedUserCreationController::CRYPTOHOME_FAILED_TPM:
       title = l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_TPM_ERROR_TITLE);
       message = l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_TPM_ERROR);
       button = l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_TPM_ERROR_BUTTON);
       break;
-    case ManagedUserCreationController::CLOUD_SERVER_ERROR:
-    case ManagedUserCreationController::TOKEN_WRITE_FAILED:
+    case SupervisedUserCreationController::CLOUD_SERVER_ERROR:
+    case SupervisedUserCreationController::TOKEN_WRITE_FAILED:
       title = l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR_TITLE);
       message = l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR);
       button = l10n_util::GetStringUTF16(
           IDS_CREATE_LOCALLY_MANAGED_USER_GENERIC_ERROR_BUTTON);
       break;
-    case ManagedUserCreationController::NO_ERROR:
+    case SupervisedUserCreationController::NO_ERROR:
       NOTREACHED();
   }
   if (actor_)
     actor_->ShowErrorPage(title, message, button);
 }
 
-void LocallyManagedUserCreationScreen::OnCreationTimeout() {
+void SupervisedUserCreationScreen::OnCreationTimeout() {
   if (actor_) {
     actor_->ShowStatusMessage(false /* error */, l10n_util::GetStringUTF16(
         IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_TIMEOUT_MESSAGE));
   }
 }
 
-void LocallyManagedUserCreationScreen::OnLongCreationWarning() {
+void SupervisedUserCreationScreen::OnLongCreationWarning() {
   if (actor_) {
     actor_->ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
         IDS_PROFILES_CREATE_SUPERVISED_JUST_SIGNED_IN));
   }
 }
 
-bool LocallyManagedUserCreationScreen::FindUserByDisplayName(
+bool SupervisedUserCreationScreen::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(SupervisedUserSyncService::kName,
                              &user_display_name)) {
       if (display_name == user_display_name) {
         if (out_id)
           *out_id = it.key();
         return true;
       }
     }
   }
   return false;
 }
 
 // TODO(antrim) : this is an explicit code duplications with UserImageScreen.
 // It should be removed by issue 251179.
 
-void LocallyManagedUserCreationScreen::ApplyPicture() {
-  std::string user_id = controller_->GetManagedUserId();
+void SupervisedUserCreationScreen::ApplyPicture() {
+  std::string user_id = controller_->GetSupervisedUserId();
   UserManager* user_manager = UserManager::Get();
   UserImageManager* image_manager = user_manager->GetUserImageManager(user_id);
   switch (selected_image_) {
     case User::kExternalImageIndex:
       // Photo decoding may not have been finished yet.
       if (user_photo_.isNull()) {
         apply_photo_after_decoding_ = true;
         return;
       }
       image_manager->SaveUserImage(
           user_manager::UserImage::CreateAndEncode(user_photo_));
       break;
     case User::kProfileImageIndex:
       NOTREACHED() << "Supervised users have no profile pictures";
       break;
     default:
       DCHECK(selected_image_ >= 0 && selected_image_ < kDefaultImagesCount);
       image_manager->SaveUserDefaultImageIndex(selected_image_);
       break;
   }
   // Proceed to tutorial.
   actor_->ShowTutorialPage();
 }
 
-void LocallyManagedUserCreationScreen::OnCreationSuccess() {
+void SupervisedUserCreationScreen::OnCreationSuccess() {
   ApplyPicture();
 }
 
-void LocallyManagedUserCreationScreen::OnCameraPresenceCheckDone(
+void SupervisedUserCreationScreen::OnCameraPresenceCheckDone(
     bool is_camera_present) {
   if (actor_)
     actor_->SetCameraPresent(is_camera_present);
 }
 
-void LocallyManagedUserCreationScreen::OnGetManagedUsers(
+void SupervisedUserCreationScreen::OnGetSupervisedUsers(
     const base::DictionaryValue* users) {
   // Copy for passing to WebUI, contains only id, name and avatar URL.
   scoped_ptr<base::ListValue> ui_users(new base::ListValue());
   SupervisedUserManager* supervised_user_manager =
       UserManager::Get()->GetSupervisedUserManager();
 
   // Stored copy, contains all necessary information.
   existing_users_.reset(new base::DictionaryValue());
   for (base::DictionaryValue::Iterator it(*users); !it.IsAtEnd();
        it.Advance()) {
     // 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;
+    int avatar_index = SupervisedUserCreationController::kDummyAvatarIndex;
     std::string chromeos_avatar;
     if (local_copy->GetString(SupervisedUserSyncService::kChromeOsAvatar,
                               &chromeos_avatar) &&
         !chromeos_avatar.empty() &&
         SupervisedUserSyncService::GetAvatarIndex(
             chromeos_avatar, &avatar_index)) {
       ui_copy->SetString(kAvatarURLKey, GetDefaultImageUrl(avatar_index));
     } else {
       int i = base::RandInt(kFirstDefaultImageIndex, kDefaultImagesCount - 1);
       local_copy->SetString(
@@ skipping 27 matching lines @@
         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());
+  actor_->ShowExistingSupervisedUsers(ui_users.get());
 }
 
-void LocallyManagedUserCreationScreen::OnPhotoTaken(
+void SupervisedUserCreationScreen::OnPhotoTaken(
     const std::string& raw_data) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   user_photo_ = gfx::ImageSkia();
   if (image_decoder_.get())
     image_decoder_->set_delegate(NULL);
   image_decoder_ = new ImageDecoder(this, raw_data,
                                     ImageDecoder::DEFAULT_CODEC);
   scoped_refptr<base::MessageLoopProxy> task_runner =
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::UI);
   image_decoder_->Start(task_runner);
 }
 
-void LocallyManagedUserCreationScreen::OnImageDecoded(
+void SupervisedUserCreationScreen::OnImageDecoded(
     const ImageDecoder* decoder,
     const SkBitmap& decoded_image) {
   DCHECK_EQ(image_decoder_.get(), decoder);
   user_photo_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
   if (apply_photo_after_decoding_)
     ApplyPicture();
 }
 
-void LocallyManagedUserCreationScreen::OnDecodeImageFailed(
+void SupervisedUserCreationScreen::OnDecodeImageFailed(
     const ImageDecoder* decoder) {
   NOTREACHED() << "Failed to decode PNG image from WebUI";
 }
 
-void LocallyManagedUserCreationScreen::OnImageSelected(
+void SupervisedUserCreationScreen::OnImageSelected(
     const std::string& image_type,
     const std::string& image_url) {
   if (image_url.empty())
     return;
   int user_image_index = User::kInvalidImageIndex;
   if (image_type == "default" &&
       IsDefaultImageUrl(image_url, &user_image_index)) {
     selected_image_ = user_image_index;
   } else if (image_type == "camera") {
     selected_image_ = User::kExternalImageIndex;
   } else {
     NOTREACHED() << "Unexpected image type: " << image_type;
   }
 }
 
-void LocallyManagedUserCreationScreen::OnImageAccepted() {
+void SupervisedUserCreationScreen::OnImageAccepted() {
 }
 
 }  // namespace chromeos