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