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

chrome/browser/ui/webui/chromeos/login/supervised_user_creation_screen_handler.cc

 // Copyright (c) 2012 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/ui/webui/chromeos/login/locally_managed_user_creation_screen_handler.h"
+#include "chrome/browser/ui/webui/chromeos/login/supervised_user_creation_screen_handler.h"
 
 #include "ash/audio/sounds.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/login/managed/locally_managed_user_creation_flow.h"
 #include "chrome/browser/chromeos/login/screens/user_selection_screen.h"
+#include "chrome/browser/chromeos/login/supervised/supervised_user_creation_flow.h"
 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/audio/chromeos_sounds.h"
 #include "components/user_manager/user_type.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "net/base/data_url.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 const char kJsScreenPath[] = "login.LocallyManagedUserCreationScreen";
 
 namespace chromeos {
 
-LocallyManagedUserCreationScreenHandler::
-LocallyManagedUserCreationScreenHandler()
+SupervisedUserCreationScreenHandler::SupervisedUserCreationScreenHandler()
     : BaseScreenHandler(kJsScreenPath),
       delegate_(NULL) {
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   media::SoundsManager* manager = media::SoundsManager::Get();
   manager->Initialize(SOUND_OBJECT_DELETE,
                       bundle.GetRawDataResource(IDR_SOUND_OBJECT_DELETE_WAV));
   manager->Initialize(SOUND_CAMERA_SNAP,
                       bundle.GetRawDataResource(IDR_SOUND_CAMERA_SNAP_WAV));
 }
 
-LocallyManagedUserCreationScreenHandler::
-    ~LocallyManagedUserCreationScreenHandler() {
+SupervisedUserCreationScreenHandler::~SupervisedUserCreationScreenHandler() {
   if (delegate_) {
     delegate_->OnActorDestroyed(this);
   }
 }
 
-void LocallyManagedUserCreationScreenHandler::DeclareLocalizedValues(
+void SupervisedUserCreationScreenHandler::DeclareLocalizedValues(
     LocalizedValuesBuilder* builder) {
   builder->Add(
       "managedUserCreationFlowRetryButtonTitle",
       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_ERROR_RETRY_BUTTON_TITLE);
   builder->Add(
       "managedUserCreationFlowCancelButtonTitle",
       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_ERROR_CANCEL_BUTTON_TITLE);
   builder->Add(
       "managedUserCreationFlowGotitButtonTitle",
        IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_GOT_IT_BUTTON_TITLE);
@@ skipping 87 matching lines @@
   builder->Add("photoFlippedAccessibleText",
                IDS_OPTIONS_PHOTO_FLIP_ACCESSIBLE_TEXT);
   builder->Add("photoFlippedBackAccessibleText",
                IDS_OPTIONS_PHOTO_FLIPBACK_ACCESSIBLE_TEXT);
   builder->Add("photoCaptureAccessibleText",
                IDS_OPTIONS_PHOTO_CAPTURE_ACCESSIBLE_TEXT);
   builder->Add("photoDiscardAccessibleText",
                IDS_OPTIONS_PHOTO_DISCARD_ACCESSIBLE_TEXT);
 }
 
-void LocallyManagedUserCreationScreenHandler::Initialize() {}
+void SupervisedUserCreationScreenHandler::Initialize() {}
 
-void LocallyManagedUserCreationScreenHandler::RegisterMessages() {
+void SupervisedUserCreationScreenHandler::RegisterMessages() {
   AddCallback("finishLocalManagedUserCreation",
-              &LocallyManagedUserCreationScreenHandler::
-                  HandleFinishLocalManagedUserCreation);
+              &SupervisedUserCreationScreenHandler::
+                  HandleFinishLocalSupervisedUserCreation);
   AddCallback("abortLocalManagedUserCreation",
-              &LocallyManagedUserCreationScreenHandler::
-                  HandleAbortLocalManagedUserCreation);
+              &SupervisedUserCreationScreenHandler::
+                  HandleAbortLocalSupervisedUserCreation);
   AddCallback("checkLocallyManagedUserName",
-              &LocallyManagedUserCreationScreenHandler::
-                  HandleCheckLocallyManagedUserName);
+              &SupervisedUserCreationScreenHandler::
+                  HandleCheckSupervisedUserName);
   AddCallback("authenticateManagerInLocallyManagedUserCreationFlow",
-              &LocallyManagedUserCreationScreenHandler::
+              &SupervisedUserCreationScreenHandler::
                   HandleAuthenticateManager);
   AddCallback("specifyLocallyManagedUserCreationFlowUserData",
-              &LocallyManagedUserCreationScreenHandler::
-                  HandleCreateManagedUser);
+              &SupervisedUserCreationScreenHandler::
+                  HandleCreateSupervisedUser);
   AddCallback("managerSelectedOnLocallyManagedUserCreationFlow",
-              &LocallyManagedUserCreationScreenHandler::
+              &SupervisedUserCreationScreenHandler::
                   HandleManagerSelected);
   AddCallback("userSelectedForImportInManagedUserCreationFlow",
-              &LocallyManagedUserCreationScreenHandler::
+              &SupervisedUserCreationScreenHandler::
                   HandleImportUserSelected);
   AddCallback("importSupervisedUser",
-              &LocallyManagedUserCreationScreenHandler::
+              &SupervisedUserCreationScreenHandler::
                   HandleImportSupervisedUser);
   AddCallback("importSupervisedUserWithPassword",
-              &LocallyManagedUserCreationScreenHandler::
+              &SupervisedUserCreationScreenHandler::
                   HandleImportSupervisedUserWithPassword);
 
 
   // TODO(antrim) : this is an explicit code duplications with UserImageScreen.
   // It should be removed by issue 251179.
   AddCallback("supervisedUserGetImages",
-              &LocallyManagedUserCreationScreenHandler::
-                  HandleGetImages);
+              &SupervisedUserCreationScreenHandler::HandleGetImages);
 
   AddCallback("supervisedUserPhotoTaken",
-              &LocallyManagedUserCreationScreenHandler::HandlePhotoTaken);
+              &SupervisedUserCreationScreenHandler::HandlePhotoTaken);
   AddCallback("supervisedUserTakePhoto",
-              &LocallyManagedUserCreationScreenHandler::HandleTakePhoto);
+              &SupervisedUserCreationScreenHandler::HandleTakePhoto);
   AddCallback("supervisedUserDiscardPhoto",
-              &LocallyManagedUserCreationScreenHandler::HandleDiscardPhoto);
+              &SupervisedUserCreationScreenHandler::HandleDiscardPhoto);
   AddCallback("supervisedUserSelectImage",
-              &LocallyManagedUserCreationScreenHandler::HandleSelectImage);
+              &SupervisedUserCreationScreenHandler::HandleSelectImage);
   AddCallback("currentSupervisedUserPage",
-              &LocallyManagedUserCreationScreenHandler::
+              &SupervisedUserCreationScreenHandler::
                   HandleCurrentSupervisedUserPage);
 }
 
-void LocallyManagedUserCreationScreenHandler::PrepareToShow() {}
+void SupervisedUserCreationScreenHandler::PrepareToShow() {}
 
-void LocallyManagedUserCreationScreenHandler::Show() {
+void SupervisedUserCreationScreenHandler::Show() {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   scoped_ptr<base::ListValue> users_list(new base::ListValue());
   const UserList& users = UserManager::Get()->GetUsers();
   std::string owner;
   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
 
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if ((*it)->GetType() != user_manager::USER_TYPE_REGULAR)
       continue;
     bool is_owner = ((*it)->email() == owner);
     base::DictionaryValue* user_dict = new base::DictionaryValue();
     UserSelectionScreen::FillUserDictionary(
         *it,
         is_owner,
         false /* is_signin_to_add */,
         ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
         user_dict);
     users_list->Append(user_dict);
   }
   data->Set("managers", users_list.release());
-  ShowScreen(OobeUI::kScreenManagedUserCreationFlow, data.get());
+  ShowScreen(OobeUI::kScreenSupervisedUserCreationFlow, data.get());
 
   if (!delegate_)
     return;
 }
 
-void LocallyManagedUserCreationScreenHandler::Hide() {
+void SupervisedUserCreationScreenHandler::Hide() {
 }
 
-void LocallyManagedUserCreationScreenHandler::ShowIntroPage() {
+void SupervisedUserCreationScreenHandler::ShowIntroPage() {
   CallJS("showIntroPage");
 }
 
-void LocallyManagedUserCreationScreenHandler::ShowManagerPasswordError() {
+void SupervisedUserCreationScreenHandler::ShowManagerPasswordError() {
   CallJS("showManagerPasswordError");
 }
 
-void LocallyManagedUserCreationScreenHandler::ShowStatusMessage(
+void SupervisedUserCreationScreenHandler::ShowStatusMessage(
     bool is_progress,
     const base::string16& message) {
   if (is_progress)
     CallJS("showProgress", message);
   else
     CallJS("showStatusError", message);
 }
 
-void LocallyManagedUserCreationScreenHandler::ShowUsernamePage() {
+void SupervisedUserCreationScreenHandler::ShowUsernamePage() {
   CallJS("showUsernamePage");
 }
 
-void LocallyManagedUserCreationScreenHandler::ShowTutorialPage() {
+void SupervisedUserCreationScreenHandler::ShowTutorialPage() {
   CallJS("showTutorialPage");
 }
 
-void LocallyManagedUserCreationScreenHandler::ShowErrorPage(
+void SupervisedUserCreationScreenHandler::ShowErrorPage(
     const base::string16& title,
     const base::string16& message,
     const base::string16& button_text) {
   CallJS("showErrorPage", title, message, button_text);
 }
 
-void LocallyManagedUserCreationScreenHandler::SetDelegate(Delegate* delegate) {
+void SupervisedUserCreationScreenHandler::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 }
 
-void LocallyManagedUserCreationScreenHandler::
-    HandleFinishLocalManagedUserCreation() {
+void SupervisedUserCreationScreenHandler::
+    HandleFinishLocalSupervisedUserCreation() {
   delegate_->FinishFlow();
 }
 
-void LocallyManagedUserCreationScreenHandler::
-    HandleAbortLocalManagedUserCreation() {
+void SupervisedUserCreationScreenHandler::
+    HandleAbortLocalSupervisedUserCreation() {
   delegate_->AbortFlow();
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleManagerSelected(
+void SupervisedUserCreationScreenHandler::HandleManagerSelected(
     const std::string& manager_id) {
   if (!delegate_)
     return;
   WallpaperManager::Get()->SetUserWallpaperNow(manager_id);
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleImportUserSelected(
+void SupervisedUserCreationScreenHandler::HandleImportUserSelected(
     const std::string& user_id) {
   if (!delegate_)
     return;
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleCheckLocallyManagedUserName(
+void SupervisedUserCreationScreenHandler::HandleCheckSupervisedUserName(
     const base::string16& name) {
   std::string user_id;
   if (NULL != UserManager::Get()->GetSupervisedUserManager()->
           FindByDisplayName(base::CollapseWhitespace(name, true))) {
     CallJS("managedUserNameError", name,
            l10n_util::GetStringUTF16(
                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_USERNAME_ALREADY_EXISTS));
   } else if (net::EscapeForHTML(name) != name) {
     CallJS("managedUserNameError", name,
            l10n_util::GetStringUTF16(
                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_ILLEGAL_USERNAME));
   } else if (delegate_ && delegate_->FindUserByDisplayName(
                  base::CollapseWhitespace(name, true), &user_id)) {
     CallJS("managedUserSuggestImport", name, user_id);
   } else {
     CallJS("managedUserNameOk", name);
   }
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleCreateManagedUser(
+void SupervisedUserCreationScreenHandler::HandleCreateSupervisedUser(
     const base::string16& new_raw_user_name,
     const std::string& new_user_password) {
   if (!delegate_)
     return;
   const base::string16 new_user_name =
       base::CollapseWhitespace(new_raw_user_name, true);
   if (NULL != UserManager::Get()->GetSupervisedUserManager()->
           FindByDisplayName(new_user_name)) {
     CallJS("managedUserNameError", new_user_name,
            l10n_util::GetStringFUTF16(
@@ skipping 11 matching lines @@
   if (new_user_password.length() == 0) {
     CallJS("showPasswordError",
            l10n_util::GetStringUTF16(
                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_TOO_SHORT));
     return;
   }
 
   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 
-  delegate_->CreateManagedUser(new_user_name, new_user_password);
+  delegate_->CreateSupervisedUser(new_user_name, new_user_password);
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleImportSupervisedUser(
+void SupervisedUserCreationScreenHandler::HandleImportSupervisedUser(
     const std::string& user_id) {
   if (!delegate_)
     return;
 
   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 
-  delegate_->ImportManagedUser(user_id);
+  delegate_->ImportSupervisedUser(user_id);
 }
 
-void LocallyManagedUserCreationScreenHandler::
+void SupervisedUserCreationScreenHandler::
     HandleImportSupervisedUserWithPassword(
         const std::string& user_id,
         const std::string& password) {
   if (!delegate_)
     return;
 
   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 
-  delegate_->ImportManagedUserWithPassword(user_id, password);
+  delegate_->ImportSupervisedUserWithPassword(user_id, password);
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleAuthenticateManager(
+void SupervisedUserCreationScreenHandler::HandleAuthenticateManager(
     const std::string& raw_manager_username,
     const std::string& manager_password) {
   const std::string manager_username =
       gaia::SanitizeEmail(raw_manager_username);
 
-  UserFlow* flow = new LocallyManagedUserCreationFlow(manager_username);
+  UserFlow* flow = new SupervisedUserCreationFlow(manager_username);
   UserManager::Get()->SetUserFlow(manager_username, flow);
 
   delegate_->AuthenticateManager(manager_username, manager_password);
 }
 
 // TODO(antrim) : this is an explicit code duplications with UserImageScreen.
 // It should be removed by issue 251179.
-void LocallyManagedUserCreationScreenHandler::HandleGetImages() {
+void SupervisedUserCreationScreenHandler::HandleGetImages() {
   base::ListValue image_urls;
   for (int i = kFirstDefaultImageIndex; i < kDefaultImagesCount; ++i) {
     scoped_ptr<base::DictionaryValue> image_data(new base::DictionaryValue);
     image_data->SetString("url", GetDefaultImageUrl(i));
     image_data->SetString(
         "author", l10n_util::GetStringUTF16(kDefaultImageAuthorIDs[i]));
     image_data->SetString(
         "website", l10n_util::GetStringUTF16(kDefaultImageWebsiteIDs[i]));
     image_data->SetString("title", GetDefaultImageDescription(i));
     image_urls.Append(image_data.release());
   }
   CallJS("setDefaultImages", image_urls);
 }
 
-void LocallyManagedUserCreationScreenHandler::HandlePhotoTaken
+void SupervisedUserCreationScreenHandler::HandlePhotoTaken
     (const std::string& image_url) {
   std::string mime_type, charset, raw_data;
   if (!net::DataURL::Parse(GURL(image_url), &mime_type, &charset, &raw_data))
     NOTREACHED();
   DCHECK_EQ("image/png", mime_type);
 
   if (delegate_)
     delegate_->OnPhotoTaken(raw_data);
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleTakePhoto() {
+void SupervisedUserCreationScreenHandler::HandleTakePhoto() {
   ash::PlaySystemSoundIfSpokenFeedback(SOUND_CAMERA_SNAP);
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleDiscardPhoto() {
+void SupervisedUserCreationScreenHandler::HandleDiscardPhoto() {
   ash::PlaySystemSoundIfSpokenFeedback(SOUND_OBJECT_DELETE);
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleSelectImage(
+void SupervisedUserCreationScreenHandler::HandleSelectImage(
     const std::string& image_url,
     const std::string& image_type) {
   if (delegate_)
     delegate_->OnImageSelected(image_type, image_url);
 }
 
-void LocallyManagedUserCreationScreenHandler::HandleCurrentSupervisedUserPage(
+void SupervisedUserCreationScreenHandler::HandleCurrentSupervisedUserPage(
     const std::string& page) {
   if (delegate_)
     delegate_->OnPageSelected(page);
 }
 
-void LocallyManagedUserCreationScreenHandler::ShowPage(
+void SupervisedUserCreationScreenHandler::ShowPage(
     const std::string& page) {
   CallJS("showPage", page);
 }
 
-void LocallyManagedUserCreationScreenHandler::SetCameraPresent(bool present) {
+void SupervisedUserCreationScreenHandler::SetCameraPresent(bool present) {
   CallJS("setCameraPresent", present);
 }
 
-void LocallyManagedUserCreationScreenHandler::ShowExistingManagedUsers(
+void SupervisedUserCreationScreenHandler::ShowExistingSupervisedUsers(
     const base::ListValue* users) {
   CallJS("setExistingManagedUsers", *users);
 }
 
 }  // namespace chromeos