src/chrome/browser/ui/webui/chromeos/login/locally_managed_user_creation_screen_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/chromeos/login/locally_managed_user_creation_screen_handler.h"
   6
   7 #include "ash/audio/sounds.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "base/values.h"
  10 #include "chrome/browser/chromeos/camera_presence_notifier.h"
  11 #include "chrome/browser/chromeos/login/managed/locally_managed_user_creation_flow.h"
  12 #include "chrome/browser/chromeos/login/supervised_user_manager.h"
  13 #include "chrome/browser/chromeos/login/user_manager.h"
  14 #include "chrome/browser/chromeos/login/wallpaper_manager.h"
  15 #include "chrome/browser/chromeos/settings/cros_settings.h"
  16 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
  17 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
  18 #include "chrome/common/url_constants.h"
  19 #include "chromeos/audio/chromeos_sounds.h"
  20 #include "google_apis/gaia/gaia_auth_util.h"
  21 #include "grit/browser_resources.h"
  22 #include "grit/generated_resources.h"
  23 #include "net/base/data_url.h"
  24 #include "net/base/escape.h"
  25 #include "ui/base/l10n/l10n_util.h"
  26 #include "ui/base/resource/resource_bundle.h"
  27
  28 const char kJsScreenPath[] = "login.LocallyManagedUserCreationScreen";
  29
  30 namespace chromeos {
  31
  32 LocallyManagedUserCreationScreenHandler::
  33 LocallyManagedUserCreationScreenHandler()
  34     : BaseScreenHandler(kJsScreenPath),
  35       delegate_(NULL) {
  36   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
  37   media::SoundsManager* manager = media::SoundsManager::Get();
  38   manager->Initialize(SOUND_OBJECT_DELETE,
  39                       bundle.GetRawDataResource(IDR_SOUND_OBJECT_DELETE_WAV));
  40   manager->Initialize(SOUND_CAMERA_SNAP,
  41                       bundle.GetRawDataResource(IDR_SOUND_CAMERA_SNAP_WAV));
  42 }
  43
  44 LocallyManagedUserCreationScreenHandler::
  45     ~LocallyManagedUserCreationScreenHandler() {
  46   if (delegate_) {
  47     CameraPresenceNotifier::GetInstance()->RemoveObserver(delegate_);
  48     delegate_->OnActorDestroyed(this);
  49   }
  50 }
  51
  52 void LocallyManagedUserCreationScreenHandler::DeclareLocalizedValues(
  53     LocalizedValuesBuilder* builder) {
  54   builder->Add(
  55       "managedUserCreationFlowRetryButtonTitle",
  56       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_ERROR_RETRY_BUTTON_TITLE);
  57   builder->Add(
  58       "managedUserCreationFlowCancelButtonTitle",
  59       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_ERROR_CANCEL_BUTTON_TITLE);
  60   builder->Add(
  61       "managedUserCreationFlowGotitButtonTitle",
  62        IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_GOT_IT_BUTTON_TITLE);
  63
  64   builder->Add("createManagedUserIntroTextTitle",
  65                IDS_CREATE_LOCALLY_MANAGED_INTRO_TEXT_TITLE);
  66   builder->Add("createManagedUserIntroAlternateText",
  67                IDS_CREATE_LOCALLY_MANAGED_INTRO_ALTERNATE_TEXT);
  68   builder->Add("createManagedUserIntroText1",
  69                IDS_CREATE_LOCALLY_MANAGED_INTRO_TEXT_1);
  70   builder->Add("createManagedUserIntroManagerItem1",
  71                IDS_CREATE_LOCALLY_MANAGED_INTRO_MANAGER_ITEM_1);
  72   builder->Add("createManagedUserIntroManagerItem2",
  73                IDS_CREATE_LOCALLY_MANAGED_INTRO_MANAGER_ITEM_2);
  74   builder->Add("createManagedUserIntroManagerItem3",
  75                IDS_CREATE_LOCALLY_MANAGED_INTRO_MANAGER_ITEM_3);
  76   builder->Add("createManagedUserIntroText2",
  77                IDS_CREATE_LOCALLY_MANAGED_INTRO_TEXT_2);
  78   builder->AddF("createManagedUserIntroText3",
  79                IDS_CREATE_LOCALLY_MANAGED_INTRO_TEXT_3,
  80                base::UTF8ToUTF16(chrome::kSupervisedUserManagementDisplayURL));
  81
  82   builder->Add("createManagedUserPickManagerTitle",
  83                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PICK_MANAGER_TITLE);
  84   builder->AddF("createManagedUserPickManagerTitleExplanation",
  85                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PICK_MANAGER_EXPLANATION,
  86                base::UTF8ToUTF16(chrome::kSupervisedUserManagementDisplayURL));
  87   builder->Add("createManagedUserManagerPasswordHint",
  88                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_MANAGER_PASSWORD_HINT);
  89   builder->Add("createManagedUserWrongManagerPasswordText",
  90                IDS_CREATE_LOCALLY_MANAGED_USER_MANAGER_PASSWORD_ERROR);
  91
  92   builder->Add("createManagedUserNameTitle",
  93                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_ACCOUNT_NAME_TITLE);
  94   builder->Add("createManagedUserNameAccessibleTitle",
  95                IDS_CREATE_LOCALLY_MANAGED_USER_SETUP_ACCESSIBLE_TITLE);
  96   builder->Add("createManagedUserNameExplanation",
  97                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_ACCOUNT_NAME_EXPLANATION);
  98   builder->Add("createManagedUserNameHint",
  99                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_ACCOUNT_NAME_HINT);
 100   builder->Add("createManagedUserPasswordTitle",
 101                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_TITLE);
 102   builder->Add("createManagedUserPasswordExplanation",
 103                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_EXPLANATION);
 104   builder->Add("createManagedUserPasswordHint",
 105                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_HINT);
 106   builder->Add("createManagedUserPasswordConfirmHint",
 107                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_CONFIRM_HINT);
 108   builder->Add("managedUserCreationFlowProceedButtonTitle",
 109                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_CONTINUE_BUTTON_TEXT);
 110   builder->Add("managedUserCreationFlowStartButtonTitle",
 111                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_START_BUTTON_TEXT);
 112   builder->Add("managedUserCreationFlowPrevButtonTitle",
 113                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PREVIOUS_BUTTON_TEXT);
 114   builder->Add("managedUserCreationFlowNextButtonTitle",
 115                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_NEXT_BUTTON_TEXT);
 116   builder->Add("managedUserCreationFlowHandleErrorButtonTitle",
 117                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_HANDLE_ERROR_BUTTON_TEXT);
 118   builder->Add("createManagedUserPasswordMismatchError",
 119                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_MISMATCH_ERROR);
 120
 121   builder->Add("createManagedUserCreatedText1",
 122                IDS_CREATE_LOCALLY_MANAGED_USER_CREATED_1_TEXT_1);
 123   builder->Add("createManagedUserCreatedText2",
 124                IDS_CREATE_LOCALLY_MANAGED_USER_CREATED_1_TEXT_2);
 125   builder->Add("createManagedUserCreatedText3",
 126                IDS_CREATE_LOCALLY_MANAGED_USER_CREATED_1_TEXT_3);
 127
 128   builder->Add("importExistingSupervisedUserTitle",
 129                IDS_IMPORT_EXISTING_MANAGED_USER_TITLE);
 130   builder->Add("importExistingSupervisedUserText",
 131                IDS_IMPORT_EXISTING_MANAGED_USER_TEXT);
 132   builder->Add("managedUserCreationFlowImportButtonTitle",
 133                IDS_IMPORT_EXISTING_MANAGED_USER_OK);
 134   builder->Add("importSupervisedUserLink",
 135                IDS_PROFILES_IMPORT_EXISTING_MANAGED_USER_LINK);
 136   builder->Add("createSupervisedUserLink",
 137                IDS_CREATE_NEW_USER_LINK);
 138   builder->Add("importBubbleText", IDS_SUPERVISED_USER_IMPORT_BUBBLE_TEXT);
 139   builder->Add("importUserExists", IDS_SUPERVISED_USER_IMPORT_USER_EXIST);
 140   builder->Add("importUsernameExists",
 141                IDS_SUPERVISED_USER_IMPORT_USERNAME_EXIST);
 142
 143   builder->Add("managementURL", chrome::kSupervisedUserManagementDisplayURL);
 144
 145   // TODO(antrim) : this is an explicit code duplications with UserImageScreen.
 146   // It should be removed by issue 251179.
 147   builder->Add("takePhoto", IDS_OPTIONS_CHANGE_PICTURE_TAKE_PHOTO);
 148   builder->Add("discardPhoto", IDS_OPTIONS_CHANGE_PICTURE_DISCARD_PHOTO);
 149   builder->Add("flipPhoto", IDS_OPTIONS_CHANGE_PICTURE_FLIP_PHOTO);
 150   builder->Add("photoFlippedAccessibleText",
 151                IDS_OPTIONS_PHOTO_FLIP_ACCESSIBLE_TEXT);
 152   builder->Add("photoFlippedBackAccessibleText",
 153                IDS_OPTIONS_PHOTO_FLIPBACK_ACCESSIBLE_TEXT);
 154   builder->Add("photoCaptureAccessibleText",
 155                IDS_OPTIONS_PHOTO_CAPTURE_ACCESSIBLE_TEXT);
 156   builder->Add("photoDiscardAccessibleText",
 157                IDS_OPTIONS_PHOTO_DISCARD_ACCESSIBLE_TEXT);
 158 }
 159
 160 void LocallyManagedUserCreationScreenHandler::Initialize() {}
 161
 162 void LocallyManagedUserCreationScreenHandler::RegisterMessages() {
 163   AddCallback("finishLocalManagedUserCreation",
 164               &LocallyManagedUserCreationScreenHandler::
 165                   HandleFinishLocalManagedUserCreation);
 166   AddCallback("abortLocalManagedUserCreation",
 167               &LocallyManagedUserCreationScreenHandler::
 168                   HandleAbortLocalManagedUserCreation);
 169   AddCallback("checkLocallyManagedUserName",
 170               &LocallyManagedUserCreationScreenHandler::
 171                   HandleCheckLocallyManagedUserName);
 172   AddCallback("authenticateManagerInLocallyManagedUserCreationFlow",
 173               &LocallyManagedUserCreationScreenHandler::
 174                   HandleAuthenticateManager);
 175   AddCallback("specifyLocallyManagedUserCreationFlowUserData",
 176               &LocallyManagedUserCreationScreenHandler::
 177                   HandleCreateManagedUser);
 178   AddCallback("managerSelectedOnLocallyManagedUserCreationFlow",
 179               &LocallyManagedUserCreationScreenHandler::
 180                   HandleManagerSelected);
 181   AddCallback("userSelectedForImportInManagedUserCreationFlow",
 182               &LocallyManagedUserCreationScreenHandler::
 183                   HandleImportUserSelected);
 184   AddCallback("importSupervisedUser",
 185               &LocallyManagedUserCreationScreenHandler::
 186                   HandleImportSupervisedUser);
 187   AddCallback("importSupervisedUserWithPassword",
 188               &LocallyManagedUserCreationScreenHandler::
 189                   HandleImportSupervisedUserWithPassword);
 190
 191
 192   // TODO(antrim) : this is an explicit code duplications with UserImageScreen.
 193   // It should be removed by issue 251179.
 194   AddCallback("supervisedUserGetImages",
 195               &LocallyManagedUserCreationScreenHandler::
 196                   HandleGetImages);
 197
 198   AddCallback("supervisedUserPhotoTaken",
 199               &LocallyManagedUserCreationScreenHandler::HandlePhotoTaken);
 200   AddCallback("supervisedUserTakePhoto",
 201               &LocallyManagedUserCreationScreenHandler::HandleTakePhoto);
 202   AddCallback("supervisedUserDiscardPhoto",
 203               &LocallyManagedUserCreationScreenHandler::HandleDiscardPhoto);
 204   AddCallback("supervisedUserSelectImage",
 205               &LocallyManagedUserCreationScreenHandler::HandleSelectImage);
 206   AddCallback("currentSupervisedUserPage",
 207               &LocallyManagedUserCreationScreenHandler::
 208                   HandleCurrentSupervisedUserPage);
 209 }
 210
 211 void LocallyManagedUserCreationScreenHandler::PrepareToShow() {}
 212
 213 void LocallyManagedUserCreationScreenHandler::Show() {
 214   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
 215   scoped_ptr<base::ListValue> users_list(new base::ListValue());
 216   const UserList& users = UserManager::Get()->GetUsers();
 217   std::string owner;
 218   chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
 219
 220   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
 221     if ((*it)->GetType() != User::USER_TYPE_REGULAR)
 222       continue;
 223     bool is_owner = ((*it)->email() == owner);
 224     base::DictionaryValue* user_dict = new base::DictionaryValue();
 225     SigninScreenHandler::FillUserDictionary(*it,
 226                                             is_owner,
 227                                             false /* is_signin_to_add */,
 228                                             LoginDisplay::OFFLINE_PASSWORD,
 229                                             user_dict);
 230     users_list->Append(user_dict);
 231   }
 232   data->Set("managers", users_list.release());
 233   ShowScreen(OobeUI::kScreenManagedUserCreationFlow, data.get());
 234
 235   if (!delegate_)
 236     return;
 237   CameraPresenceNotifier::GetInstance()->AddObserver(delegate_);
 238 }
 239
 240 void LocallyManagedUserCreationScreenHandler::Hide() {
 241   if (delegate_)
 242     CameraPresenceNotifier::GetInstance()->RemoveObserver(delegate_);
 243 }
 244
 245 void LocallyManagedUserCreationScreenHandler::ShowIntroPage() {
 246   CallJS("showIntroPage");
 247 }
 248
 249 void LocallyManagedUserCreationScreenHandler::ShowManagerPasswordError() {
 250   CallJS("showManagerPasswordError");
 251 }
 252
 253 void LocallyManagedUserCreationScreenHandler::ShowStatusMessage(
 254     bool is_progress,
 255     const base::string16& message) {
 256   if (is_progress)
 257     CallJS("showProgress", message);
 258   else
 259     CallJS("showStatusError", message);
 260 }
 261
 262 void LocallyManagedUserCreationScreenHandler::ShowUsernamePage() {
 263   CallJS("showUsernamePage");
 264 }
 265
 266 void LocallyManagedUserCreationScreenHandler::ShowTutorialPage() {
 267   CallJS("showTutorialPage");
 268 }
 269
 270 void LocallyManagedUserCreationScreenHandler::ShowErrorPage(
 271     const base::string16& title,
 272     const base::string16& message,
 273     const base::string16& button_text) {
 274   CallJS("showErrorPage", title, message, button_text);
 275 }
 276
 277 void LocallyManagedUserCreationScreenHandler::SetDelegate(Delegate* delegate) {
 278   delegate_ = delegate;
 279 }
 280
 281 void LocallyManagedUserCreationScreenHandler::
 282     HandleFinishLocalManagedUserCreation() {
 283   delegate_->FinishFlow();
 284 }
 285
 286 void LocallyManagedUserCreationScreenHandler::
 287     HandleAbortLocalManagedUserCreation() {
 288   delegate_->AbortFlow();
 289 }
 290
 291 void LocallyManagedUserCreationScreenHandler::HandleManagerSelected(
 292     const std::string& manager_id) {
 293   if (!delegate_)
 294     return;
 295   WallpaperManager::Get()->SetUserWallpaperNow(manager_id);
 296 }
 297
 298 void LocallyManagedUserCreationScreenHandler::HandleImportUserSelected(
 299     const std::string& user_id) {
 300   if (!delegate_)
 301     return;
 302 }
 303
 304 void LocallyManagedUserCreationScreenHandler::HandleCheckLocallyManagedUserName(
 305     const base::string16& name) {
 306   std::string user_id;
 307   if (NULL != UserManager::Get()->GetSupervisedUserManager()->
 308           FindByDisplayName(base::CollapseWhitespace(name, true))) {
 309     CallJS("managedUserNameError", name,
 310            l10n_util::GetStringUTF16(
 311                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_USERNAME_ALREADY_EXISTS));
 312   } else if (net::EscapeForHTML(name) != name) {
 313     CallJS("managedUserNameError", name,
 314            l10n_util::GetStringUTF16(
 315                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_ILLEGAL_USERNAME));
 316   } else if (delegate_ && delegate_->FindUserByDisplayName(
 317                  base::CollapseWhitespace(name, true), &user_id)) {
 318     CallJS("managedUserSuggestImport", name, user_id);
 319   } else {
 320     CallJS("managedUserNameOk", name);
 321   }
 322 }
 323
 324 void LocallyManagedUserCreationScreenHandler::HandleCreateManagedUser(
 325     const base::string16& new_raw_user_name,
 326     const std::string& new_user_password) {
 327   if (!delegate_)
 328     return;
 329   const base::string16 new_user_name =
 330       base::CollapseWhitespace(new_raw_user_name, true);
 331   if (NULL != UserManager::Get()->GetSupervisedUserManager()->
 332           FindByDisplayName(new_user_name)) {
 333     CallJS("managedUserNameError", new_user_name,
 334            l10n_util::GetStringFUTF16(
 335                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_USERNAME_ALREADY_EXISTS,
 336                new_user_name));
 337     return;
 338   }
 339   if (net::EscapeForHTML(new_user_name) != new_user_name) {
 340     CallJS("managedUserNameError", new_user_name,
 341            l10n_util::GetStringUTF16(
 342                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_ILLEGAL_USERNAME));
 343     return;
 344   }
 345
 346   if (new_user_password.length() == 0) {
 347     CallJS("showPasswordError",
 348            l10n_util::GetStringUTF16(
 349                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_TOO_SHORT));
 350     return;
 351   }
 352
 353   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
 354       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 355
 356   delegate_->CreateManagedUser(new_user_name, new_user_password);
 357 }
 358
 359 void LocallyManagedUserCreationScreenHandler::HandleImportSupervisedUser(
 360     const std::string& user_id) {
 361   if (!delegate_)
 362     return;
 363
 364   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
 365       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 366
 367   delegate_->ImportManagedUser(user_id);
 368 }
 369
 370 void LocallyManagedUserCreationScreenHandler::
 371     HandleImportSupervisedUserWithPassword(
 372         const std::string& user_id,
 373         const std::string& password) {
 374   if (!delegate_)
 375     return;
 376
 377   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
 378       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 379
 380   delegate_->ImportManagedUserWithPassword(user_id, password);
 381 }
 382
 383 void LocallyManagedUserCreationScreenHandler::HandleAuthenticateManager(
 384     const std::string& raw_manager_username,
 385     const std::string& manager_password) {
 386   const std::string manager_username =
 387       gaia::SanitizeEmail(raw_manager_username);
 388
 389   UserFlow* flow = new LocallyManagedUserCreationFlow(manager_username);
 390   UserManager::Get()->SetUserFlow(manager_username, flow);
 391
 392   delegate_->AuthenticateManager(manager_username, manager_password);
 393 }
 394
 395 // TODO(antrim) : this is an explicit code duplications with UserImageScreen.
 396 // It should be removed by issue 251179.
 397 void LocallyManagedUserCreationScreenHandler::HandleGetImages() {
 398   base::ListValue image_urls;
 399   for (int i = kFirstDefaultImageIndex; i < kDefaultImagesCount; ++i) {
 400     scoped_ptr<base::DictionaryValue> image_data(new base::DictionaryValue);
 401     image_data->SetString("url", GetDefaultImageUrl(i));
 402     image_data->SetString(
 403         "author", l10n_util::GetStringUTF16(kDefaultImageAuthorIDs[i]));
 404     image_data->SetString(
 405         "website", l10n_util::GetStringUTF16(kDefaultImageWebsiteIDs[i]));
 406     image_data->SetString("title", GetDefaultImageDescription(i));
 407     image_urls.Append(image_data.release());
 408   }
 409   CallJS("setDefaultImages", image_urls);
 410 }
 411
 412 void LocallyManagedUserCreationScreenHandler::HandlePhotoTaken
 413     (const std::string& image_url) {
 414   std::string mime_type, charset, raw_data;
 415   if (!net::DataURL::Parse(GURL(image_url), &mime_type, &charset, &raw_data))
 416     NOTREACHED();
 417   DCHECK_EQ("image/png", mime_type);
 418
 419   if (delegate_)
 420     delegate_->OnPhotoTaken(raw_data);
 421 }
 422
 423 void LocallyManagedUserCreationScreenHandler::HandleTakePhoto() {
 424   ash::PlaySystemSoundIfSpokenFeedback(SOUND_CAMERA_SNAP);
 425 }
 426
 427 void LocallyManagedUserCreationScreenHandler::HandleDiscardPhoto() {
 428   ash::PlaySystemSoundIfSpokenFeedback(SOUND_OBJECT_DELETE);
 429 }
 430
 431 void LocallyManagedUserCreationScreenHandler::HandleSelectImage(
 432     const std::string& image_url,
 433     const std::string& image_type) {
 434   if (delegate_)
 435     delegate_->OnImageSelected(image_type, image_url);
 436 }
 437
 438 void LocallyManagedUserCreationScreenHandler::HandleCurrentSupervisedUserPage(
 439     const std::string& page) {
 440   if (delegate_)
 441     delegate_->OnPageSelected(page);
 442 }
 443
 444 void LocallyManagedUserCreationScreenHandler::ShowPage(
 445     const std::string& page) {
 446   CallJS("showPage", page);
 447 }
 448
 449 void LocallyManagedUserCreationScreenHandler::SetCameraPresent(bool present) {
 450   CallJS("setCameraPresent", present);
 451 }
 452
 453 void LocallyManagedUserCreationScreenHandler::ShowExistingManagedUsers(
 454     const base::ListValue* users) {
 455   CallJS("setExistingManagedUsers", *users);
 456 }
 457
 458 }  // namespace chromeos