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                base::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                base::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<base::DictionaryValue> data(new base::DictionaryValue());
 189   scoped_ptr<base::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     base::DictionaryValue* user_dict = new base::DictionaryValue();
 199     SigninScreenHandler::FillUserDictionary(*it,
 200                                             is_owner,
 201                                             false /* is_signin_to_add */,
 202                                             user_dict);
 203     users_list->Append(user_dict);
 204   }
 205   data->Set("managers", users_list.release());
 206   ShowScreen(OobeUI::kScreenManagedUserCreationFlow, data.get());
 207
 208   if (!delegate_)
 209     return;
 210   delegate_->CheckCameraPresence();
 211 }
 212
 213 void LocallyManagedUserCreationScreenHandler::Hide() {}
 214
 215 void LocallyManagedUserCreationScreenHandler::ShowIntroPage() {
 216   CallJS("showIntroPage");
 217 }
 218
 219 void LocallyManagedUserCreationScreenHandler::ShowManagerPasswordError() {
 220   CallJS("showManagerPasswordError");
 221 }
 222
 223 void LocallyManagedUserCreationScreenHandler::ShowStatusMessage(
 224     bool is_progress,
 225     const base::string16& message) {
 226   if (is_progress)
 227     CallJS("showProgress", message);
 228   else
 229     CallJS("showStatusError", message);
 230 }
 231
 232 void LocallyManagedUserCreationScreenHandler::ShowUsernamePage() {
 233   CallJS("showUsernamePage");
 234 }
 235
 236 void LocallyManagedUserCreationScreenHandler::ShowTutorialPage() {
 237   CallJS("showTutorialPage");
 238 }
 239
 240 void LocallyManagedUserCreationScreenHandler::ShowErrorPage(
 241     const base::string16& title,
 242     const base::string16& message,
 243     const base::string16& button_text) {
 244   CallJS("showErrorPage", title, message, button_text);
 245 }
 246
 247 void LocallyManagedUserCreationScreenHandler::SetDelegate(Delegate* delegate) {
 248   delegate_ = delegate;
 249 }
 250
 251 void LocallyManagedUserCreationScreenHandler::
 252     HandleFinishLocalManagedUserCreation() {
 253   delegate_->FinishFlow();
 254 }
 255
 256 void LocallyManagedUserCreationScreenHandler::
 257     HandleAbortLocalManagedUserCreation() {
 258   delegate_->AbortFlow();
 259 }
 260
 261 void LocallyManagedUserCreationScreenHandler::HandleManagerSelected(
 262     const std::string& manager_id) {
 263   if (!delegate_)
 264     return;
 265   WallpaperManager::Get()->SetUserWallpaperNow(manager_id);
 266 }
 267
 268 void LocallyManagedUserCreationScreenHandler::HandleImportUserSelected(
 269     const std::string& user_id) {
 270   if (!delegate_)
 271     return;
 272 }
 273
 274 void LocallyManagedUserCreationScreenHandler::HandleCheckLocallyManagedUserName(
 275     const base::string16& name) {
 276   std::string user_id;
 277   if (NULL != UserManager::Get()->GetSupervisedUserManager()->
 278           FindByDisplayName(CollapseWhitespace(name, true))) {
 279     CallJS("managedUserNameError", name,
 280            l10n_util::GetStringUTF16(
 281                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_USERNAME_ALREADY_EXISTS));
 282   } else if (net::EscapeForHTML(name) != name) {
 283     CallJS("managedUserNameError", name,
 284            l10n_util::GetStringUTF16(
 285                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_ILLEGAL_USERNAME));
 286   } else if (delegate_ && delegate_->FindUserByDisplayName(
 287                  CollapseWhitespace(name, true), &user_id)) {
 288     CallJS("managedUserSuggestImport", name, user_id);
 289   } else {
 290     CallJS("managedUserNameOk", name);
 291   }
 292 }
 293
 294 void LocallyManagedUserCreationScreenHandler::HandleCreateManagedUser(
 295     const base::string16& new_raw_user_name,
 296     const std::string& new_user_password) {
 297   if (!delegate_)
 298     return;
 299   const base::string16 new_user_name =
 300       CollapseWhitespace(new_raw_user_name, true);
 301   if (NULL != UserManager::Get()->GetSupervisedUserManager()->
 302           FindByDisplayName(new_user_name)) {
 303     CallJS("managedUserNameError", new_user_name,
 304            l10n_util::GetStringFUTF16(
 305                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_USERNAME_ALREADY_EXISTS,
 306                new_user_name));
 307     return;
 308   }
 309   if (net::EscapeForHTML(new_user_name) != new_user_name) {
 310     CallJS("managedUserNameError", new_user_name,
 311            l10n_util::GetStringUTF16(
 312                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_ILLEGAL_USERNAME));
 313     return;
 314   }
 315
 316   if (new_user_password.length() == 0) {
 317     CallJS("showPasswordError",
 318            l10n_util::GetStringUTF16(
 319                IDS_CREATE_LOCALLY_MANAGED_USER_CREATE_PASSWORD_TOO_SHORT));
 320     return;
 321   }
 322
 323   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
 324       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 325
 326   delegate_->CreateManagedUser(new_user_name, new_user_password);
 327 }
 328
 329 void LocallyManagedUserCreationScreenHandler::HandleImportSupervisedUser(
 330     const std::string& user_id) {
 331   if (!delegate_)
 332     return;
 333
 334   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
 335       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 336
 337   delegate_->ImportManagedUser(user_id);
 338 }
 339
 340 void LocallyManagedUserCreationScreenHandler::
 341     HandleImportSupervisedUserWithPassword(
 342         const std::string& user_id,
 343         const std::string& password) {
 344   if (!delegate_)
 345     return;
 346
 347   ShowStatusMessage(true /* progress */, l10n_util::GetStringUTF16(
 348       IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_CREATION_PROGRESS_MESSAGE));
 349
 350   delegate_->ImportManagedUserWithPassword(user_id, password);
 351 }
 352
 353 void LocallyManagedUserCreationScreenHandler::HandleAuthenticateManager(
 354     const std::string& raw_manager_username,
 355     const std::string& manager_password) {
 356   const std::string manager_username =
 357       gaia::SanitizeEmail(raw_manager_username);
 358
 359   UserFlow* flow = new LocallyManagedUserCreationFlow(manager_username);
 360   UserManager::Get()->SetUserFlow(manager_username, flow);
 361
 362   delegate_->AuthenticateManager(manager_username, manager_password);
 363 }
 364
 365 // TODO(antrim) : this is an explicit code duplications with UserImageScreen.
 366 // It should be removed by issue 251179.
 367 void LocallyManagedUserCreationScreenHandler::HandleGetImages() {
 368   base::ListValue image_urls;
 369   for (int i = kFirstDefaultImageIndex; i < kDefaultImagesCount; ++i) {
 370     scoped_ptr<base::DictionaryValue> image_data(new base::DictionaryValue);
 371     image_data->SetString("url", GetDefaultImageUrl(i));
 372     image_data->SetString(
 373         "author", l10n_util::GetStringUTF16(kDefaultImageAuthorIDs[i]));
 374     image_data->SetString(
 375         "website", l10n_util::GetStringUTF16(kDefaultImageWebsiteIDs[i]));
 376     image_data->SetString("title", GetDefaultImageDescription(i));
 377     image_urls.Append(image_data.release());
 378   }
 379   CallJS("setDefaultImages", image_urls);
 380 }
 381
 382 void LocallyManagedUserCreationScreenHandler::HandlePhotoTaken
 383     (const std::string& image_url) {
 384   std::string mime_type, charset, raw_data;
 385   if (!net::DataURL::Parse(GURL(image_url), &mime_type, &charset, &raw_data))
 386     NOTREACHED();
 387   DCHECK_EQ("image/png", mime_type);
 388
 389   if (delegate_)
 390     delegate_->OnPhotoTaken(raw_data);
 391 }
 392
 393 void LocallyManagedUserCreationScreenHandler::HandleCheckCameraPresence() {
 394   if (!delegate_)
 395     return;
 396   delegate_->CheckCameraPresence();
 397 }
 398
 399 void LocallyManagedUserCreationScreenHandler::HandleSelectImage(
 400     const std::string& image_url,
 401     const std::string& image_type) {
 402   if (delegate_)
 403     delegate_->OnImageSelected(image_type, image_url);
 404 }
 405
 406 void LocallyManagedUserCreationScreenHandler::HandleCurrentSupervisedUserPage(
 407     const std::string& page) {
 408   if (delegate_)
 409     delegate_->OnPageSelected(page);
 410 }
 411
 412 void LocallyManagedUserCreationScreenHandler::ShowPage(
 413     const std::string& page) {
 414   CallJS("showPage", page);
 415 }
 416
 417 void LocallyManagedUserCreationScreenHandler::SetCameraPresent(bool present) {
 418   CallJS("setCameraPresent", present);
 419 }
 420
 421 void LocallyManagedUserCreationScreenHandler::ShowExistingManagedUsers(
 422     const base::ListValue* users) {
 423   CallJS("setExistingManagedUsers", *users);
 424 }
 425
 426 }  // namespace chromeos