chrome/browser/ui/webui/options/create_profile_handler.cc

   1 // Copyright 2013 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/options/create_profile_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/files/file_path.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/value_conversions.h"
  13 #include "base/values.h"
  14 #include "chrome/browser/browser_process.h"
  15 #include "chrome/browser/managed_mode/managed_user_registration_utility.h"
  16 #include "chrome/browser/managed_mode/managed_user_service.h"
  17 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
  18 #include "chrome/browser/managed_mode/managed_user_sync_service.h"
  19 #include "chrome/browser/managed_mode/managed_user_sync_service_factory.h"
  20 #include "chrome/browser/profiles/profile_manager.h"
  21 #include "chrome/browser/profiles/profile_metrics.h"
  22 #include "chrome/browser/profiles/profiles_state.h"
  23 #include "chrome/browser/sync/profile_sync_service.h"
  24 #include "chrome/browser/sync/profile_sync_service_factory.h"
  25 #include "chrome/browser/ui/webui/options/options_handlers_helper.h"
  26 #include "chrome/common/chrome_switches.h"
  27 #include "chrome/common/pref_names.h"
  28 #include "grit/generated_resources.h"
  29 #include "ui/base/l10n/l10n_util.h"
  30
  31 namespace options {
  32
  33 CreateProfileHandler::CreateProfileHandler()
  34     : profile_creation_type_(NO_CREATION_IN_PROGRESS),
  35       weak_ptr_factory_(this) {
  36 }
  37
  38 CreateProfileHandler::~CreateProfileHandler() {
  39   CancelProfileRegistration(false);
  40 }
  41
  42 void CreateProfileHandler::GetLocalizedValues(
  43     base::DictionaryValue* localized_strings) {
  44 }
  45
  46 void CreateProfileHandler::RegisterMessages() {
  47   web_ui()->RegisterMessageCallback(
  48       "cancelCreateProfile",
  49       base::Bind(&CreateProfileHandler::HandleCancelProfileCreation,
  50                  base::Unretained(this)));
  51   web_ui()->RegisterMessageCallback(
  52       "createProfile",
  53       base::Bind(&CreateProfileHandler::CreateProfile,
  54                  base::Unretained(this)));
  55 }
  56
  57 void CreateProfileHandler::CreateProfile(const base::ListValue* args) {
  58   // This handler could have been called in managed mode, for example because
  59   // the user fiddled with the web inspector. Silently return in this case.
  60   Profile* current_profile = Profile::FromWebUI(web_ui());
  61   if (current_profile->IsManaged())
  62     return;
  63
  64   if (!profiles::IsMultipleProfilesEnabled())
  65     return;
  66
  67   // We can have only one in progress profile creation
  68   // at any given moment, if new ones are initiated just
  69   // ignore them until we are done with the old one.
  70   if (profile_creation_type_ != NO_CREATION_IN_PROGRESS)
  71     return;
  72
  73   profile_creation_type_ = NON_SUPERVISED_PROFILE_CREATION;
  74
  75   DCHECK(profile_path_being_created_.empty());
  76   profile_creation_start_time_ = base::TimeTicks::Now();
  77
  78   base::string16 name;
  79   base::string16 icon;
  80   std::string managed_user_id;
  81   bool create_shortcut = false;
  82   bool managed_user = false;
  83   if (args->GetString(0, &name) && args->GetString(1, &icon)) {
  84     if (args->GetBoolean(2, &create_shortcut)) {
  85       bool success = args->GetBoolean(3, &managed_user);
  86       DCHECK(success);
  87       success = args->GetString(4, &managed_user_id);
  88       DCHECK(success);
  89     }
  90   }
  91
  92   if (managed_user) {
  93     if (!IsValidExistingManagedUserId(managed_user_id))
  94       return;
  95
  96     profile_creation_type_ = SUPERVISED_PROFILE_IMPORT;
  97     if (managed_user_id.empty()) {
  98       profile_creation_type_ = SUPERVISED_PROFILE_CREATION;
  99       managed_user_id =
 100           ManagedUserRegistrationUtility::GenerateNewManagedUserId();
 101
 102       // If sync is not yet fully initialized, the creation may take extra time,
 103       // so show a message. Import doesn't wait for an acknowledgement, so it
 104       // won't have the same potential delay.
 105       ProfileSyncService* sync_service =
 106           ProfileSyncServiceFactory::GetInstance()->GetForProfile(
 107               current_profile);
 108       ProfileSyncService::SyncStatusSummary status =
 109           sync_service->QuerySyncStatusSummary();
 110       if (status == ProfileSyncService::DATATYPES_NOT_INITIALIZED) {
 111         ShowProfileCreationWarning(l10n_util::GetStringUTF16(
 112             IDS_PROFILES_CREATE_MANAGED_JUST_SIGNED_IN));
 113       }
 114     }
 115   }
 116
 117   ProfileMetrics::LogProfileAddNewUser(ProfileMetrics::ADD_NEW_USER_DIALOG);
 118
 119   profile_path_being_created_ = ProfileManager::CreateMultiProfileAsync(
 120       name, icon,
 121       base::Bind(&CreateProfileHandler::OnProfileCreated,
 122                  weak_ptr_factory_.GetWeakPtr(),
 123                  create_shortcut,
 124                  helper::GetDesktopType(web_ui()),
 125                  managed_user_id),
 126       managed_user_id);
 127 }
 128
 129 void CreateProfileHandler::OnProfileCreated(
 130     bool create_shortcut,
 131     chrome::HostDesktopType desktop_type,
 132     const std::string& managed_user_id,
 133     Profile* profile,
 134     Profile::CreateStatus status) {
 135   if (status != Profile::CREATE_STATUS_CREATED)
 136     RecordProfileCreationMetrics(status);
 137
 138   switch (status) {
 139     case Profile::CREATE_STATUS_LOCAL_FAIL: {
 140       ShowProfileCreationError(profile,
 141                                GetProfileCreationErrorMessage(LOCAL_ERROR));
 142       break;
 143     }
 144     case Profile::CREATE_STATUS_CREATED: {
 145       // Do nothing for an intermediate status.
 146       break;
 147     }
 148     case Profile::CREATE_STATUS_INITIALIZED: {
 149       HandleProfileCreationSuccess(create_shortcut, desktop_type,
 150                                    managed_user_id, profile);
 151       break;
 152     }
 153     // User-initiated cancellation is handled in CancelProfileRegistration and
 154     // does not call this callback.
 155     case Profile::CREATE_STATUS_CANCELED:
 156     // Managed user registration errors are handled in
 157     // OnManagedUserRegistered().
 158     case Profile::CREATE_STATUS_REMOTE_FAIL:
 159     case Profile::MAX_CREATE_STATUS: {
 160       NOTREACHED();
 161       break;
 162     }
 163   }
 164 }
 165
 166 void CreateProfileHandler::HandleProfileCreationSuccess(
 167     bool create_shortcut,
 168     chrome::HostDesktopType desktop_type,
 169     const std::string& managed_user_id,
 170     Profile* profile) {
 171   switch (profile_creation_type_) {
 172     case NON_SUPERVISED_PROFILE_CREATION: {
 173       DCHECK(managed_user_id.empty());
 174       CreateShortcutAndShowSuccess(create_shortcut, desktop_type, profile);
 175       break;
 176     }
 177     case SUPERVISED_PROFILE_CREATION:
 178     case SUPERVISED_PROFILE_IMPORT:
 179       RegisterManagedUser(create_shortcut, desktop_type,
 180                           managed_user_id, profile);
 181       break;
 182     case NO_CREATION_IN_PROGRESS:
 183       NOTREACHED();
 184       break;
 185   }
 186 }
 187
 188 void CreateProfileHandler::RegisterManagedUser(
 189     bool create_shortcut,
 190     chrome::HostDesktopType desktop_type,
 191     const std::string& managed_user_id,
 192     Profile* new_profile) {
 193   DCHECK_EQ(profile_path_being_created_.value(),
 194             new_profile->GetPath().value());
 195
 196   ManagedUserService* managed_user_service =
 197       ManagedUserServiceFactory::GetForProfile(new_profile);
 198
 199   // Register the managed user using the profile of the custodian.
 200   managed_user_registration_utility_ =
 201       ManagedUserRegistrationUtility::Create(Profile::FromWebUI(web_ui()));
 202   managed_user_service->RegisterAndInitSync(
 203       managed_user_registration_utility_.get(),
 204       Profile::FromWebUI(web_ui()),
 205       managed_user_id,
 206       base::Bind(&CreateProfileHandler::OnManagedUserRegistered,
 207                  weak_ptr_factory_.GetWeakPtr(),
 208                  create_shortcut,
 209                  desktop_type,
 210                  new_profile));
 211 }
 212
 213 void CreateProfileHandler::OnManagedUserRegistered(
 214     bool create_shortcut,
 215     chrome::HostDesktopType desktop_type,
 216     Profile* profile,
 217     const GoogleServiceAuthError& error) {
 218   GoogleServiceAuthError::State state = error.state();
 219   RecordSupervisedProfileCreationMetrics(state);
 220   if (state == GoogleServiceAuthError::NONE) {
 221     CreateShortcutAndShowSuccess(create_shortcut, desktop_type, profile);
 222     return;
 223   }
 224
 225   base::string16 error_msg;
 226   if (state == GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS ||
 227       state == GoogleServiceAuthError::USER_NOT_SIGNED_UP ||
 228       state == GoogleServiceAuthError::ACCOUNT_DELETED ||
 229       state == GoogleServiceAuthError::ACCOUNT_DISABLED) {
 230     error_msg = GetProfileCreationErrorMessage(SIGNIN_ERROR);
 231   } else {
 232     error_msg = GetProfileCreationErrorMessage(REMOTE_ERROR);
 233   }
 234   ShowProfileCreationError(profile, error_msg);
 235 }
 236
 237 void CreateProfileHandler::CreateShortcutAndShowSuccess(
 238     bool create_shortcut,
 239     chrome::HostDesktopType desktop_type,
 240     Profile* profile) {
 241   if (create_shortcut) {
 242     ProfileShortcutManager* shortcut_manager =
 243         g_browser_process->profile_manager()->profile_shortcut_manager();
 244
 245     if (shortcut_manager)
 246       shortcut_manager->CreateProfileShortcut(profile->GetPath());
 247   }
 248
 249   DCHECK_EQ(profile_path_being_created_.value(), profile->GetPath().value());
 250   profile_path_being_created_.clear();
 251   DCHECK_NE(NO_CREATION_IN_PROGRESS, profile_creation_type_);
 252   base::DictionaryValue dict;
 253   dict.SetString("name",
 254                  profile->GetPrefs()->GetString(prefs::kProfileName));
 255   dict.Set("filePath", base::CreateFilePathValue(profile->GetPath()));
 256   bool is_managed =
 257       profile_creation_type_ == SUPERVISED_PROFILE_CREATION ||
 258       profile_creation_type_ == SUPERVISED_PROFILE_IMPORT;
 259   dict.SetBoolean("isManaged", is_managed);
 260   web_ui()->CallJavascriptFunction(
 261       GetJavascriptMethodName(PROFILE_CREATION_SUCCESS), dict);
 262
 263   // If the new profile is a supervised user, instead of opening a new window
 264   // right away, a confirmation overlay will be shown by JS from the creation
 265   // dialog. If we are importing an existing supervised profile or creating a
 266   // new non-supervised user profile we don't show any confirmation, so open
 267   // the new window now.
 268   if (profile_creation_type_ != SUPERVISED_PROFILE_CREATION) {
 269     // Opening the new window must be the last action, after all callbacks
 270     // have been run, to give them a chance to initialize the profile.
 271     helper::OpenNewWindowForProfile(desktop_type,
 272                                     profile,
 273                                     Profile::CREATE_STATUS_INITIALIZED);
 274   }
 275   profile_creation_type_ = NO_CREATION_IN_PROGRESS;
 276 }
 277
 278 void CreateProfileHandler::ShowProfileCreationError(
 279     Profile* profile,
 280     const base::string16& error) {
 281   DCHECK_NE(NO_CREATION_IN_PROGRESS, profile_creation_type_);
 282   profile_creation_type_ = NO_CREATION_IN_PROGRESS;
 283   profile_path_being_created_.clear();
 284   web_ui()->CallJavascriptFunction(
 285       GetJavascriptMethodName(PROFILE_CREATION_ERROR),
 286       base::StringValue(error));
 287   helper::DeleteProfileAtPath(profile->GetPath(), web_ui());
 288 }
 289
 290 void CreateProfileHandler::ShowProfileCreationWarning(
 291     const base::string16& warning) {
 292   DCHECK_EQ(SUPERVISED_PROFILE_CREATION, profile_creation_type_);
 293   web_ui()->CallJavascriptFunction("BrowserOptions.showCreateProfileWarning",
 294                                    base::StringValue(warning));
 295 }
 296
 297 void CreateProfileHandler::HandleCancelProfileCreation(
 298     const base::ListValue* args) {
 299   CancelProfileRegistration(true);
 300 }
 301
 302 void CreateProfileHandler::CancelProfileRegistration(bool user_initiated) {
 303   if (profile_path_being_created_.empty())
 304     return;
 305
 306   ProfileManager* manager = g_browser_process->profile_manager();
 307   Profile* new_profile = manager->GetProfileByPath(profile_path_being_created_);
 308   if (!new_profile)
 309     return;
 310
 311   // Non-managed user creation cannot be canceled. (Creating a non-managed
 312   // profile shouldn't take significant time, and it can easily be deleted
 313   // afterward.)
 314   if (!new_profile->IsManaged())
 315     return;
 316
 317   if (user_initiated) {
 318     UMA_HISTOGRAM_MEDIUM_TIMES(
 319         "Profile.CreateTimeCanceledNoTimeout",
 320         base::TimeTicks::Now() - profile_creation_start_time_);
 321     RecordProfileCreationMetrics(Profile::CREATE_STATUS_CANCELED);
 322   }
 323
 324   DCHECK(managed_user_registration_utility_.get());
 325   managed_user_registration_utility_.reset();
 326
 327   DCHECK_NE(NO_CREATION_IN_PROGRESS, profile_creation_type_);
 328   profile_creation_type_ = NO_CREATION_IN_PROGRESS;
 329
 330   // Cancelling registration means the callback passed into
 331   // RegisterAndInitSync() won't be called, so the cleanup must be done here.
 332   profile_path_being_created_.clear();
 333   helper::DeleteProfileAtPath(new_profile->GetPath(), web_ui());
 334 }
 335
 336 void CreateProfileHandler::RecordProfileCreationMetrics(
 337     Profile::CreateStatus status) {
 338   UMA_HISTOGRAM_ENUMERATION("Profile.CreateResult",
 339                             status,
 340                             Profile::MAX_CREATE_STATUS);
 341   UMA_HISTOGRAM_MEDIUM_TIMES(
 342       "Profile.CreateTimeNoTimeout",
 343       base::TimeTicks::Now() - profile_creation_start_time_);
 344 }
 345
 346 void CreateProfileHandler::RecordSupervisedProfileCreationMetrics(
 347     GoogleServiceAuthError::State error_state) {
 348   if (profile_creation_type_ == SUPERVISED_PROFILE_CREATION) {
 349     UMA_HISTOGRAM_ENUMERATION("Profile.SupervisedProfileCreateError",
 350                               error_state,
 351                               GoogleServiceAuthError::NUM_STATES);
 352     UMA_HISTOGRAM_MEDIUM_TIMES(
 353         "Profile.SupervisedProfileTotalCreateTime",
 354         base::TimeTicks::Now() - profile_creation_start_time_);
 355   } else {
 356     DCHECK_EQ(SUPERVISED_PROFILE_IMPORT, profile_creation_type_);
 357     UMA_HISTOGRAM_ENUMERATION("Profile.SupervisedProfileImportError",
 358                               error_state,
 359                               GoogleServiceAuthError::NUM_STATES);
 360     UMA_HISTOGRAM_MEDIUM_TIMES(
 361         "Profile.SupervisedProfileTotalImportTime",
 362         base::TimeTicks::Now() - profile_creation_start_time_);
 363   }
 364 }
 365
 366 base::string16 CreateProfileHandler::GetProfileCreationErrorMessage(
 367     ProfileCreationErrorType error) const {
 368   int message_id = -1;
 369   switch (error) {
 370     case SIGNIN_ERROR:
 371       message_id =
 372           profile_creation_type_ == SUPERVISED_PROFILE_IMPORT ?
 373               IDS_MANAGED_USER_IMPORT_SIGN_IN_ERROR :
 374               IDS_PROFILES_CREATE_SIGN_IN_ERROR;
 375       break;
 376     case REMOTE_ERROR:
 377       message_id =
 378           profile_creation_type_ == SUPERVISED_PROFILE_IMPORT ?
 379               IDS_MANAGED_USER_IMPORT_REMOTE_ERROR :
 380               IDS_PROFILES_CREATE_REMOTE_ERROR;
 381       break;
 382     case LOCAL_ERROR:
 383       message_id =
 384           profile_creation_type_ == SUPERVISED_PROFILE_IMPORT ?
 385               IDS_MANAGED_USER_IMPORT_LOCAL_ERROR :
 386               IDS_PROFILES_CREATE_LOCAL_ERROR;
 387       break;
 388   }
 389
 390   return l10n_util::GetStringUTF16(message_id);
 391 }
 392
 393 std::string CreateProfileHandler::GetJavascriptMethodName(
 394     ProfileCreationStatus status) const {
 395   switch (status) {
 396     case PROFILE_CREATION_SUCCESS:
 397       return profile_creation_type_ == SUPERVISED_PROFILE_IMPORT ?
 398           "BrowserOptions.showManagedUserImportSuccess" :
 399           "BrowserOptions.showCreateProfileSuccess";
 400     case PROFILE_CREATION_ERROR:
 401       return profile_creation_type_ == SUPERVISED_PROFILE_IMPORT ?
 402           "BrowserOptions.showManagedUserImportError" :
 403           "BrowserOptions.showCreateProfileError";
 404   }
 405
 406   NOTREACHED();
 407   return std::string();
 408 }
 409
 410 bool CreateProfileHandler::IsValidExistingManagedUserId(
 411     const std::string& existing_managed_user_id) const {
 412   if (existing_managed_user_id.empty())
 413     return true;
 414
 415   if (CommandLine::ForCurrentProcess()->HasSwitch(
 416       switches::kDisableCreateExistingManagedUsers)) {
 417     return false;
 418   }
 419
 420   Profile* profile = Profile::FromWebUI(web_ui());
 421   const base::DictionaryValue* dict =
 422       ManagedUserSyncServiceFactory::GetForProfile(profile)->GetManagedUsers();
 423   if (!dict->HasKey(existing_managed_user_id))
 424     return false;
 425
 426   // Check if this managed user already exists on this machine.
 427   const ProfileInfoCache& cache =
 428       g_browser_process->profile_manager()->GetProfileInfoCache();
 429   for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
 430     if (existing_managed_user_id == cache.GetManagedUserIdOfProfileAtIndex(i))
 431       return false;
 432   }
 433   return true;
 434 }
 435
 436 }  // namespace options