updated UI, default profile name, check for existing supervised user before create

chrome/browser/ui/webui/signin/signin_create_profile_handler.cc

 // Copyright 2016 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/signin/signin_create_profile_handler.h"
 
 #include <stddef.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
 #include "chrome/browser/profiles/profile_attributes_storage.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
 #include "chrome/browser/profiles/profiles_state.h"
+#include "chrome/browser/signin/signin_error_controller_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/webui/profile_helper.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
 #include "components/prefs/pref_service.h"
+#include "components/signin/core/browser/signin_error_controller.h"
 #include "components/strings/grit/components_strings.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_ui.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(ENABLE_SUPERVISED_USERS)
 #include "chrome/browser/supervised_user/legacy/supervised_user_registration_utility.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_sync_service.h"
 #include "chrome/browser/supervised_user/legacy/supervised_user_sync_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_service.h"
@@ skipping 10 matching lines @@
   CancelProfileRegistration(false);
 #endif
 }
 
 void SigninCreateProfileHandler::GetLocalizedValues(
     base::DictionaryValue* localized_strings) {
   localized_strings->SetString(
       "manageProfilesSupervisedSignedInLabel",
       l10n_util::GetStringUTF16(
           IDS_PROFILES_CREATE_SUPERVISED_MULTI_SIGNED_IN_LABEL));
-  localized_strings->SetString(
-      "manageProfilesSupervisedNotSignedIn",
-      l10n_util::GetStringUTF16(
-          IDS_PROFILES_CREATE_SUPERVISED_NOT_SIGNED_IN_HTML));
   localized_strings->SetString("createProfileConfirm",
                                l10n_util::GetStringUTF16(IDS_SAVE));
   localized_strings->SetString("learnMore",
                                l10n_util::GetStringUTF16(IDS_LEARN_MORE));
   localized_strings->SetString(
       "createProfileTitle",
       l10n_util::GetStringUTF16(IDS_PROFILES_CREATE_TITLE));
-
   localized_strings->SetString(
       "supervisedUserLearnMoreTitle",
       l10n_util::GetStringUTF16(IDS_LEGACY_SUPERVISED_USER_LEARN_MORE_TITLE));
   localized_strings->SetString(
       "supervisedUserLearnMoreDone",
       l10n_util::GetStringUTF16(
           IDS_LEGACY_SUPERVISED_USER_LEARN_MORE_DONE_BUTTON));
   localized_strings->SetString(
       "supervisedUserLearnMoreText",
       l10n_util::GetStringFUTF16(
           IDS_LEGACY_SUPERVISED_USER_LEARN_MORE_TEXT,
           base::ASCIIToUTF16(
               chrome::kLegacySupervisedUserManagementDisplayURL)));
+  localized_strings->SetString(
+      "manageProfilesExistingSupervisedUser",
+      l10n_util::GetStringUTF16(
+          IDS_PROFILES_CREATE_LEGACY_SUPERVISED_USER_ERROR_EXISTS_REMOTELY));
+  localized_strings->SetString(
+      "managedProfilesExistingLocalSupervisedUser",
+      l10n_util::GetStringUTF16(
+          IDS_PROFILES_CREATE_LEGACY_SUPERVISED_USER_ERROR_EXISTS_LOCALLY));
+  localized_strings->SetString(
+      "custodianAccountNotSelectedError",
+      l10n_util::GetStringUTF16(
+          IDS_PROFILES_CREATE_NO_CUSTODIAN_ACCOUNT_ERROR));
 }
 
 void SigninCreateProfileHandler::RegisterMessages() {
 #if defined(ENABLE_SUPERVISED_USERS)
   // Cancellation is only supported for supervised users.
   web_ui()->RegisterMessageCallback(
       "cancelCreateProfile",
       base::Bind(&SigninCreateProfileHandler::HandleCancelProfileCreation,
                  base::Unretained(this)));
 #endif
@@ skipping 21 matching lines @@
   for (size_t i = 0; i < profiles::GetDefaultAvatarIconCount() &&
                      i != placeholder_avatar_index;
        i++) {
     std::string url = profiles::GetDefaultAvatarIconUrl(i);
     image_url_list.AppendString(url);
   }
 
   web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
                                    base::StringValue("profile-icons-received"),
                                    image_url_list);
+
+  SendNewProfileDefaults();
+}
+
+void SigninCreateProfileHandler::SendNewProfileDefaults() {
+  ProfileInfoCache& cache =
+      g_browser_process->profile_manager()->GetProfileInfoCache();
+  base::DictionaryValue profile_info;
+  profile_info.SetString("name", cache.ChooseNameForNewProfile(0));
+
+  web_ui()->CallJavascriptFunction(
+      "cr.webUIListenerCallback",
+      base::StringValue("profile-defaults-received"),
+      profile_info);
 }
 
 void SigninCreateProfileHandler::RequestSignedInProfiles(
     const base::ListValue* args) {
   base::ListValue user_info_list;
   std::vector<ProfileAttributesEntry*> entries =
       g_browser_process->profile_manager()->
           GetProfileAttributesStorage().GetAllProfilesAttributesSortedByName();
   for (ProfileAttributesEntry* entry : entries) {
     base::string16 username = entry->GetUserName();
@@ skipping 34 matching lines @@
     base::TrimWhitespace(name, base::TRIM_ALL, &name);
     CHECK(!name.empty());
 #ifndef NDEBUG
     size_t icon_index;
     DCHECK(profiles::IsDefaultAvatarIconUrl(icon_url, &icon_index));
 #endif
     args->GetBoolean(2, &create_shortcut);
   }
 #if defined(ENABLE_SUPERVISED_USERS)
   std::string supervised_user_id;
-  base::FilePath supervisor_profile_path;
+  base::FilePath custodian_profile_path;
   if (GetSupervisedCreateProfileArgs(args, &supervised_user_id,
-                                     &supervisor_profile_path)) {
-    // Load supervisor profile.
+                                     &custodian_profile_path)) {
+    // Load custodian profile.
     g_browser_process->profile_manager()->CreateProfileAsync(
-        supervisor_profile_path,
-        base::Bind(&SigninCreateProfileHandler::LoadSupervisorProfileCallback,
+        custodian_profile_path,
+        base::Bind(&SigninCreateProfileHandler::LoadCustodianProfileCallback,
                    weak_ptr_factory_.GetWeakPtr(), name, icon_url,
                    create_shortcut, supervised_user_id),
         base::string16(), std::string(), std::string());
   } else {
     DoCreateProfile(name, icon_url, create_shortcut, std::string(), nullptr);
   }
 #else
   DoCreateProfile(name, icon_url, create_shortcut, std::string(), nullptr);
 #endif
 }
 
 void SigninCreateProfileHandler::DoCreateProfile(
     const base::string16& name,
     const std::string& icon_url,
     bool create_shortcut,
     const std::string& supervised_user_id,
-    Profile* supervisor_profile) {
+    Profile* custodian_profile) {
   ProfileMetrics::LogProfileAddNewUser(ProfileMetrics::ADD_NEW_USER_DIALOG);
 
   profile_path_being_created_ = ProfileManager::CreateMultiProfileAsync(
       name, icon_url,
       base::Bind(&SigninCreateProfileHandler::OnProfileCreated,
                  weak_ptr_factory_.GetWeakPtr(), create_shortcut,
-                 supervised_user_id, supervisor_profile),
+                 supervised_user_id, custodian_profile),
       supervised_user_id);
 }
 
 void SigninCreateProfileHandler::OnProfileCreated(
     bool create_shortcut,
     const std::string& supervised_user_id,
-    Profile* supervisor_profile,
+    Profile* custodian_profile,
     Profile* profile,
     Profile::CreateStatus status) {
   if (status != Profile::CREATE_STATUS_CREATED)
     RecordProfileCreationMetrics(status);
 
   switch (status) {
     case Profile::CREATE_STATUS_LOCAL_FAIL: {
       ShowProfileCreationError(profile, GetProfileCreationErrorMessageLocal());
       break;
     }
     case Profile::CREATE_STATUS_CREATED: {
       // Do nothing for an intermediate status.
       break;
     }
     case Profile::CREATE_STATUS_INITIALIZED: {
       HandleProfileCreationSuccess(create_shortcut, supervised_user_id,
-                                   supervisor_profile, profile);
+                                   custodian_profile, profile);
       break;
     }
     // User-initiated cancellation is handled in CancelProfileRegistration and
     // does not call this callback.
     case Profile::CREATE_STATUS_CANCELED:
     // Supervised user registration errors are handled in
     // OnSupervisedUserRegistered().
     case Profile::CREATE_STATUS_REMOTE_FAIL:
     case Profile::MAX_CREATE_STATUS: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void SigninCreateProfileHandler::HandleProfileCreationSuccess(
     bool create_shortcut,
     const std::string& supervised_user_id,
-    Profile* supervisor_profile,
+    Profile* custodian_profile,
     Profile* profile) {
   switch (profile_creation_type_) {
     case NON_SUPERVISED_PROFILE_CREATION: {
       DCHECK(supervised_user_id.empty());
       CreateShortcutAndShowSuccess(create_shortcut, profile);
       break;
     }
 #if defined(ENABLE_SUPERVISED_USERS)
     case SUPERVISED_PROFILE_CREATION:
     case SUPERVISED_PROFILE_IMPORT:
       RegisterSupervisedUser(create_shortcut, supervised_user_id,
-                             supervisor_profile, profile);
+                             custodian_profile, profile);
       break;
 #endif
     case NO_CREATION_IN_PROGRESS:
       NOTREACHED();
       break;
   }
 }
 
 void SigninCreateProfileHandler::CreateShortcutAndShowSuccess(
     bool create_shortcut,
@@ skipping 39 matching lines @@
     webui::OpenNewWindowForProfile(
         profile, Profile::CREATE_STATUS_INITIALIZED);
   }
   profile_creation_type_ = NO_CREATION_IN_PROGRESS;
 }
 
 void SigninCreateProfileHandler::ShowProfileCreationError(
     Profile* profile,
     const base::string16& error) {
   DCHECK_NE(NO_CREATION_IN_PROGRESS, profile_creation_type_);
-  profile_creation_type_ = NO_CREATION_IN_PROGRESS;
-  profile_path_being_created_.clear();
   web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
                                    GetWebUIListenerName(PROFILE_CREATION_ERROR),
                                    base::StringValue(error));
   // The ProfileManager calls us back with a NULL profile in some cases.
   if (profile)
     webui::DeleteProfileAtPath(profile->GetPath(), web_ui());
+  profile_creation_type_ = NO_CREATION_IN_PROGRESS;
+  profile_path_being_created_.clear();
 }
 
 void SigninCreateProfileHandler::RecordProfileCreationMetrics(
     Profile::CreateStatus status) {
   UMA_HISTOGRAM_ENUMERATION("Profile.CreateResult", status,
                             Profile::MAX_CREATE_STATUS);
   UMA_HISTOGRAM_MEDIUM_TIMES(
       "Profile.CreateTimeNoTimeout",
       base::TimeTicks::Now() - profile_creation_start_time_);
 }
@@ skipping 51 matching lines @@
   }
 
   NOTREACHED();
   return base::StringValue(std::string());
 }
 
 #if defined(ENABLE_SUPERVISED_USERS)
 bool SigninCreateProfileHandler::GetSupervisedCreateProfileArgs(
     const base::ListValue* args,
     std::string* supervised_user_id,
-    base::FilePath* supervisor_profile_path) {
+    base::FilePath* custodian_profile_path) {
   bool supervised_user = false;
   bool success = args->GetBoolean(3, &supervised_user);
   DCHECK(success);
 
   if (!supervised_user)
     return false;
 
   success = args->GetString(4, supervised_user_id);
   DCHECK(success);
   const base::Value* path_value;
   success = args->Get(5, &path_value);
   DCHECK(success);
-  success = base::GetValueAsFilePath(*path_value, supervisor_profile_path);
+  success = base::GetValueAsFilePath(*path_value, custodian_profile_path);
   DCHECK(success);
 
-  return !supervisor_profile_path->empty();
+  return !custodian_profile_path->empty();
 }
 
-void SigninCreateProfileHandler::LoadSupervisorProfileCallback(
+void SigninCreateProfileHandler::LoadCustodianProfileCallback(
     const base::string16& name,
     const std::string& icon_url,
     bool create_shortcut,
     const std::string& supervised_user_id,
-    Profile* supervisor_profile,
+    Profile* custodian_profile,
     Profile::CreateStatus status) {
   // This method gets called once before with Profile::CREATE_STATUS_CREATED.
   switch (status) {
     case Profile::CREATE_STATUS_LOCAL_FAIL: {
       // TODO(mahmadi): see if a better error message is required here.
       ShowProfileCreationError(nullptr, GetProfileCreationErrorMessageLocal());
       break;
     }
     case Profile::CREATE_STATUS_CREATED: {
       // Ignore the intermediate status.
       break;
     }
     case Profile::CREATE_STATUS_INITIALIZED: {
       // We are only interested in Profile::CREATE_STATUS_INITIALIZED when
       // everything is ready.
-      // TODO(mahmadi): display proper error message to the user.
-      PrefService* prefs = supervisor_profile->GetPrefs();
+      if (!IsAccountConnected(custodian_profile) ||
+          HasAuthError(custodian_profile)) {
+        ShowProfileCreationError(nullptr, l10n_util::GetStringUTF16(
+          IDS_PROFILES_CREATE_CUSTODIAN_ACCOUNT_DETAILS_OUT_OF_DATE_ERROR));
+        return;
+      }
+
+      PrefService* prefs = custodian_profile->GetPrefs();
       if (!prefs->GetBoolean(prefs::kSupervisedUserCreationAllowed))
         return;
 
       if (!supervised_user_id.empty()) {
         profile_creation_type_ = SUPERVISED_PROFILE_IMPORT;
 
         SupervisedUserSyncService* supervised_user_sync_service =
-            SupervisedUserSyncServiceFactory::GetForProfile(supervisor_profile);
+            SupervisedUserSyncServiceFactory::GetForProfile(custodian_profile);
         if (supervised_user_sync_service) {
           supervised_user_sync_service->GetSupervisedUsersAsync(base::Bind(
               &SigninCreateProfileHandler::DoCreateProfileIfPossible,
               weak_ptr_factory_.GetWeakPtr(), name, icon_url, create_shortcut,
-              supervised_user_id, supervisor_profile));
+              supervised_user_id, custodian_profile));
         }
       } else {
         profile_creation_type_ = SUPERVISED_PROFILE_CREATION;
         std::string new_supervised_user_id =
             SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId();
 
         // If sync is not yet fully initialized, the creation may take extra
         // time, so show a message. Import doesn't wait for an acknowledgment,
         // so it won't have the same potential delay.
         ProfileSyncService* sync_service =
             ProfileSyncServiceFactory::GetInstance()->GetForProfile(
-                supervisor_profile);
+                custodian_profile);
         ProfileSyncService::SyncStatusSummary status =
             sync_service->QuerySyncStatusSummary();
         if (status == ProfileSyncService::DATATYPES_NOT_INITIALIZED) {
           ShowProfileCreationWarning(l10n_util::GetStringUTF16(
               IDS_PROFILES_CREATE_SUPERVISED_JUST_SIGNED_IN));
         }
 
         DoCreateProfile(name, icon_url, create_shortcut, new_supervised_user_id,
-                        supervisor_profile);
+                        custodian_profile);
       }
       break;
     }
     case Profile::CREATE_STATUS_CANCELED:
     case Profile::CREATE_STATUS_REMOTE_FAIL:
     case Profile::MAX_CREATE_STATUS: {
       NOTREACHED();
       break;
     }
   }
 }
 
+bool SigninCreateProfileHandler::IsAccountConnected(Profile* profile)
+    const {
+  SigninManagerBase* signin_manager =
+      SigninManagerFactory::GetForProfile(profile);
+  return signin_manager && signin_manager->IsAuthenticated();
+}
+
+bool SigninCreateProfileHandler::HasAuthError(Profile* profile)
+    const {
+  SigninErrorController* error_controller =
+      SigninErrorControllerFactory::GetForProfile(profile);
+  if (!error_controller)
+    return true;
+
+  GoogleServiceAuthError::State state = error_controller->auth_error().state();
+  return state != GoogleServiceAuthError::NONE;
+}
+
 void SigninCreateProfileHandler::DoCreateProfileIfPossible(
     const base::string16& name,
     const std::string& icon_url,
     bool create_shortcut,
     const std::string& supervised_user_id,
-    Profile* supervisor_profile,
+    Profile* custodian_profile,
     const base::DictionaryValue* dict) {
   DCHECK(dict);
   if (!dict->HasKey(supervised_user_id))
     return;
 
   // Check if this supervised user already exists on this machine.
   std::vector<ProfileAttributesEntry*> entries =
       g_browser_process->profile_manager()->
           GetProfileAttributesStorage().GetAllProfilesAttributes();
   for (ProfileAttributesEntry* entry : entries) {
     if (supervised_user_id == entry->GetSupervisedUserId()) {
       // TODO(mahmadi): see whether we need a more specific error message here.
       ShowProfileCreationError(nullptr, GetProfileCreationErrorMessageLocal());
       return;
     }
   }
 
   DoCreateProfile(name, icon_url, create_shortcut, supervised_user_id,
-                  supervisor_profile);
+                  custodian_profile);
 }
 
 void SigninCreateProfileHandler::HandleCancelProfileCreation(
     const base::ListValue* args) {
   CancelProfileRegistration(true);
 }
 
 // Non-supervised user creation cannot be canceled. (Creating a non-supervised
 // profile shouldn't take significant time, and it can easily be deleted
 // afterward.)
@@ skipping 22 matching lines @@
 
   // Canceling registration means the callback passed into
   // RegisterAndInitSync() won't be called, so the cleanup must be done here.
   profile_path_being_created_.clear();
   webui::DeleteProfileAtPath(new_profile->GetPath(), web_ui());
 }
 
 void SigninCreateProfileHandler::RegisterSupervisedUser(
     bool create_shortcut,
     const std::string& supervised_user_id,
-    Profile* supervisor_profile,
+    Profile* custodian_profile,
     Profile* new_profile) {
   DCHECK_EQ(profile_path_being_created_.value(),
             new_profile->GetPath().value());
 
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(new_profile);
 
   // Register the supervised user using the profile of the custodian.
   supervised_user_registration_utility_ =
-      SupervisedUserRegistrationUtility::Create(supervisor_profile);
+      SupervisedUserRegistrationUtility::Create(custodian_profile);
   supervised_user_service->RegisterAndInitSync(
-      supervised_user_registration_utility_.get(), supervisor_profile,
+      supervised_user_registration_utility_.get(), custodian_profile,
       supervised_user_id,
       base::Bind(&SigninCreateProfileHandler::OnSupervisedUserRegistered,
                  weak_ptr_factory_.GetWeakPtr(), create_shortcut, new_profile));
 }
 
 void SigninCreateProfileHandler::OnSupervisedUserRegistered(
     bool create_shortcut,
     Profile* profile,
     const GoogleServiceAuthError& error) {
   GoogleServiceAuthError::State state = error.state();
@@ skipping 35 matching lines @@
     DCHECK_EQ(SUPERVISED_PROFILE_IMPORT, profile_creation_type_);
     UMA_HISTOGRAM_ENUMERATION("Profile.SupervisedProfileImportError",
                               error_state, GoogleServiceAuthError::NUM_STATES);
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "Profile.SupervisedProfileTotalImportTime",
         base::TimeTicks::Now() - profile_creation_start_time_);
   }
 }
 
 #endif