Add error handling for supervised user import flow.

chrome/browser/resources/options/manage_profile_overlay.js

 // Copyright (c) 2012 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.
 
 cr.define('options', function() {
   var OptionsPage = options.OptionsPage;
   var ArrayDataModel = cr.ui.ArrayDataModel;
 
   /**
    * ManageProfileOverlay class
@@ skipping 40 matching lines @@
       // Override the create-profile-ok and create-* keydown handlers, to avoid
       // closing the overlay until we finish creating the profile.
       $('create-profile-ok').onclick = function(event) {
         self.submitCreateProfile_();
       };
 
       $('create-profile-cancel').onclick = function(event) {
         CreateProfileOverlay.cancelCreateProfile();
       };
 
-      $('import-existing-managed-user-link').hidden =
-          !loadTimeData.getBoolean('allowCreateExistingManagedUsers');
-
       $('manage-profile-cancel').onclick =
           $('delete-profile-cancel').onclick = function(event) {
         OptionsPage.closeOverlay();
       };
       $('delete-profile-ok').onclick = function(event) {
         OptionsPage.closeOverlay();
         if (BrowserOptions.getCurrentProfile().isManaged)
           return;
         chrome.send('deleteProfile', [self.profileInfo_.filePath]);
+        options.ManagedUserListData.reloadExistingManagedUsers();

[Pam (message me for reviews), 2014/01/08 17:21:16]

Since deleting a profile locally doesn't remove it from the manager's list, this
shouldn't be needed.

[Adrian Kuegel, 2014/01/09 08:56:34]

There is one small change: it will have the onCurrentDevice property updated, so
it will be possible again to import this supervised user. So I think this might
make sense here.

[Pam (message me for reviews), 2014/01/09 09:00:19]

Ah, yes, you're quite right!

       };
       $('add-shortcut-button').onclick = function(event) {
         chrome.send('addProfileShortcut', [self.profileInfo_.filePath]);
       };
       $('remove-shortcut-button').onclick = function(event) {
         chrome.send('removeProfileShortcut', [self.profileInfo_.filePath]);
       };
 
       $('create-profile-managed-signed-in-learn-more-link').onclick =
           function(event) {
@@ skipping 10 matching lines @@
         OptionsPage.closeOverlay();
         SyncSetupOverlay.startSignIn();
       };
 
       $('create-profile-managed-sign-in-again-link').onclick = function(event) {
         OptionsPage.closeOverlay();
         SyncSetupOverlay.showSetupUI();
       };
 
       $('import-existing-managed-user-link').onclick = function(event) {
-        OptionsPage.closeOverlay();
         OptionsPage.navigateToPage('managedUserImport');
       };
     },
 
     /** @override */
     didShowPage: function() {
       chrome.send('requestDefaultProfileIcons');
 
       // Just ignore the manage profile dialog on Chrome OS, they use /accounts.
       if (!cr.isChromeOS && window.location.pathname == '/manageProfile')
@@ skipping 13 matching lines @@
       var manageNameField = $('manage-profile-name');
       // Supervised users cannot edit their names.
       if (manageNameField.disabled)
         $('manage-profile-ok').focus();
       else
         manageNameField.focus();
     },
 
     /**
      * Registers event handlers that are common between create and manage modes.
-     * @param {string} mode A label that specifies the type of dialog
-     *     box which is currently being viewed (i.e. 'create' or
-     *     'manage').
+     * @param {string} mode A label that specifies the type of dialog box which
+     *     is currently being viewed (i.e. 'create' or 'manage').
      * @param {function()} submitFunction The function that should be called
      *     when the user chooses to submit (e.g. by clicking the OK button).
      * @private
      */
     registerCommonEventHandlers_: function(mode, submitFunction) {
       var self = this;
       $(mode + '-profile-icon-grid').addEventListener('change', function(e) {
         self.onIconGridSelectionChanged_(mode);
       });
       $(mode + '-profile-name').oninput = function(event) {
-        self.onNameChanged_(event, mode);
+        self.onNameChanged_(mode);
       };
       $(mode + '-profile-ok').onclick = function(event) {
         OptionsPage.closeOverlay();
         submitFunction();
       };
     },
 
     /**
      * Set the profile info used in the dialog.
      * @param {Object} profileInfo An object of the form:
      *     profileInfo = {
      *       name: "Profile Name",
      *       iconURL: "chrome://path/to/icon/image",
      *       filePath: "/path/to/profile/data/on/disk",
      *       isCurrentProfile: false,
      *       isManaged: false
      *     };
-     * @param {string} mode A label that specifies the type of dialog
-     *     box which is currently being viewed (i.e. 'create' or
-     *     'manage').
+     * @param {string} mode A label that specifies the type of dialog box which
+     *     is currently being viewed (i.e. 'create' or 'manage').
      * @private
      */
     setProfileInfo_: function(profileInfo, mode) {
       this.iconGridSelectedURL_ = profileInfo.iconURL;
       this.profileInfo_ = profileInfo;
       $(mode + '-profile-name').value = profileInfo.name;
       $(mode + '-profile-icon-grid').selectedItem = profileInfo.iconURL;
     },
 
     /**
@@ skipping 68 matching lines @@
      * message.
      * @param {boolean} hasShortcuts Whether profile has any existing shortcuts.
      * @private
      */
     receiveHasProfileShortcuts_: function(hasShortcuts) {
       $('add-shortcut-button').hidden = hasShortcuts;
       $('remove-shortcut-button').hidden = !hasShortcuts;
     },
 
     /**
-     * Display the error bubble, with |errorText| in the bubble.
-     * @param {string} errorText The string to display as an error.
-     * @param {string} mode A label that specifies the type of dialog
-     *     box which is currently being viewed (i.e. 'create' or
-     *     'manage').
+     * Display the error bubble, with |errorHtml| in the bubble.
+     * @param {string} errorHtml The html string to display as an error.
+     * @param {string} mode A label that specifies the type of dialog box which
+     *     is currently being viewed (i.e. 'create' or 'manage').
      * @param {boolean} disableOKButton True if the dialog's OK button should be
      *     disabled when the error bubble is shown. It will be (re-)enabled when
      *     the error bubble is hidden.
      * @private
      */
-    showErrorBubble_: function(errorText, mode, disableOKButton) {
+    showErrorBubble_: function(errorHtml, mode, disableOKButton) {
       var nameErrorEl = $(mode + '-profile-error-bubble');
       nameErrorEl.hidden = false;
-      nameErrorEl.textContent = errorText;
+      nameErrorEl.innerHTML = errorHtml;
 
       if (disableOKButton)
         $(mode + '-profile-ok').disabled = true;
     },
 
     /**
      * Hide the error bubble.
-     * @param {string} mode A label that specifies the type of dialog
-     *     box which is currently being viewed (i.e. 'create' or
-     *     'manage').
+     * @param {string} mode A label that specifies the type of dialog box which
+     *     is currently being viewed (i.e. 'create' or 'manage').
      * @private
      */
     hideErrorBubble_: function(mode) {
       $(mode + '-profile-error-bubble').hidden = true;
       $(mode + '-profile-ok').disabled = false;
     },
 
     /**
      * oninput callback for <input> field.
-     * @param {Event} event The event object.
-     * @param {string} mode A label that specifies the type of dialog
-     *     box which is currently being viewed (i.e. 'create' or
-     *     'manage').
+     * @param {string} mode A label that specifies the type of dialog box which
+     *     is currently being viewed (i.e. 'create' or 'manage').
      * @private
      */
-    onNameChanged_: function(event, mode) {
-      var newName = event.target.value;
+    onNameChanged_: function(mode) {
+      var newName = $(mode + '-profile-name').value;
       var oldName = this.profileInfo_.name;
 
-      if (newName == oldName) {
+      // In 'create' mode, the initial name can be the name of an already
+      // existing supervised user.
+      if (newName == oldName && mode == 'manage') {
         this.hideErrorBubble_(mode);
       } else if (this.profileNames_[newName] != undefined) {
-        var errorText =
+        var errorHtml =
             loadTimeData.getString('manageProfilesDuplicateNameError');
-        this.showErrorBubble_(errorText, mode, true);
+        this.showErrorBubble_(errorHtml, mode, true);
+      } else if (mode == 'create' &&
+                 loadTimeData.getBoolean('allowCreateExistingManagedUsers')) {
+        this.checkIfSupervisedUserExists_();
       } else {
-        this.hideErrorBubble_(mode);
-
-        var nameIsValid = $(mode + '-profile-name').validity.valid;
-        $(mode + '-profile-ok').disabled = !nameIsValid;
+        this.updateOkButton_(mode);
       }
     },
 
     /**
+     * Checks if a supervised user with the currently entered name already
+     * exists.
+     * @private
+     */
+    checkIfSupervisedUserExists_: function() {
+      if (!$('create-profile-managed').checked) {
+        this.updateOkButton_('create');
+        return;
+      }
+      options.ManagedUserListData.requestExistingManagedUsers(
+          this.receiveExistingManagedUsers_.bind(this),
+          this.onSigninError_.bind(this));
+    },
+
+    /**
+     * Callback which receives the list of existing managed users. Checks if the
+     * currently entered name is the name of an already existing managed user.
+     * If yes, the user is prompted to import the existing managed user, and the
+     * create button is disabled.
+     * @param {Array.<Object>} The list of existing managed users.
+     * @private
+     */
+    receiveExistingManagedUsers_: function(managedUsers) {
+      var newName = $('create-profile-name').value;
+      var i;
+      for (i = 0; i < managedUsers.length; ++i) {
+        if (managedUsers[i].name == newName &&
+            !managedUsers[i].onCurrentDevice) {
+          var errorHtml = loadTimeData.getStringF(
+              'manageProfilesExistingSupervisedUser',
+              HTMLEscape(elide(newName, /* maxLength */ 50)));
+          this.showErrorBubble_(errorHtml, 'create', true);
+
+          // Check if another supervised user also exists with that name.
+          var nameIsUnique = true;
+          var j;
+          for (j = i + 1; j < managedUsers.length; ++j) {
+            if (managedUsers[j].name == newName) {
+              nameIsUnique = false;
+              break;
+            }
+          }
+          function getImportHandler(managedUser, nameIsUnique) {
+            return function() {
+              if (managedUser.needAvatar || !nameIsUnique) {
+                OptionsPage.navigateToPage('managedUserImport');
+              } else {
+                chrome.send('createProfile',
+                    [managedUser.name, managedUser.iconURL, false, true,
+                        managedUser.id]);
+              }
+            }
+          };
+          $('supervised-user-import').onclick =
+              getImportHandler(managedUsers[i], nameIsUnique);
+          $('create-profile-ok').disabled = true;
+          return;
+        }
+      }
+      this.updateOkButton_('create');
+    },
+
+    /**
+     * Called in case the request for the list of managed users fails because of
+     * a signin error.
+     * @private
+     */
+    onSigninError_: function() {
+      this.updateImportExistingManagedUserLink_(false);
+      this.updateManagedUsersAllowed_(false);
+    },
+
+    /**
+     * Called if the name seems to be unused so far.
+     * @param {string} mode A label that specifies the type of dialog box which
+     *     is currently being viewed (i.e. 'create' or 'manage').
+     * @private
+     */
+    updateOkButton_: function(mode) {
+      this.hideErrorBubble_(mode);
+
+      var nameIsValid = $(mode + '-profile-name').validity.valid;
+      $(mode + '-profile-ok').disabled = !nameIsValid;
+    },
+
+    /**
      * Called when the user clicks "OK" or hits enter. Saves the newly changed
      * profile info.
      * @private
      */
     submitManageChanges_: function() {
       var name = $('manage-profile-name').value;
       var iconURL = $('manage-profile-icon-grid').selectedItem;
 
       chrome.send('setProfileIconAndName',
                   [this.profileInfo_.filePath, iconURL, name]);
@@ skipping 22 matching lines @@
       var existingManagedUserId = '';
 
       // 'createProfile' is handled by the CreateProfileHandler.
       chrome.send('createProfile',
                   [name, iconUrl, createShortcut,
                    isManaged, existingManagedUserId]);
     },
 
     /**
      * Called when the selected icon in the icon grid changes.
-     * @param {string} mode A label that specifies the type of dialog
-     *     box which is currently being viewed (i.e. 'create' or
-     *     'manage').
+     * @param {string} mode A label that specifies the type of dialog box which
+     *     is currently being viewed (i.e. 'create' or 'manage').
      * @private
      */
     onIconGridSelectionChanged_: function(mode) {
       var iconURL = $(mode + '-profile-icon-grid').selectedItem;
       if (!iconURL || iconURL == this.iconGridSelectedURL_)
         return;
       this.iconGridSelectedURL_ = iconURL;
       if (this.profileInfo_ && this.profileInfo_.filePath) {
         chrome.send('profileIconSelectionChanged',
                     [this.profileInfo_.filePath, iconURL]);
@@ skipping 33 matching lines @@
       if (BrowserOptions.getCurrentProfile().isManaged)
         return;
 
       ManageProfileOverlay.setProfileInfo(profileInfo, 'manage');
       $('manage-profile-overlay-create').hidden = true;
       $('manage-profile-overlay-manage').hidden = true;
       $('manage-profile-overlay-delete').hidden = false;
       $('delete-profile-icon').style.content =
           imageset(profileInfo.iconURL + '@scalefactorx');
       $('delete-profile-text').textContent =
-          loadTimeData.getStringF('deleteProfileMessage', profileInfo.name);
+          loadTimeData.getStringF('deleteProfileMessage',
+                                  elide(profileInfo.name, /* maxLength */ 50));
       $('delete-managed-profile-addendum').hidden = !profileInfo.isManaged;
 
       // Because this dialog isn't useful when refreshing or as part of the
       // history, don't create a history entry for it when showing.
       OptionsPage.showPageByName('manageProfile', false);
     },
 
     /**
      * Display the "Create Profile" dialog.
      * @private
@@ skipping 61 matching lines @@
 
       var shortcutsEnabled = loadTimeData.getBoolean('profileShortcutsEnabled');
       $('create-shortcut-container').hidden = !shortcutsEnabled;
       $('create-shortcut').checked = shortcutsEnabled;
 
       $('create-profile-name-label').hidden = true;
       $('create-profile-name').hidden = true;
       $('create-profile-ok').disabled = true;
 
       $('create-profile-managed').checked = false;
+      if (loadTimeData.getBoolean('allowCreateExistingManagedUsers')) {
+        $('import-existing-managed-user-link').hidden = false;
+        $('create-profile-managed').onchange = function() {
+          ManageProfileOverlay.getInstance().onNameChanged_('create');
+        };
+      }
       $('create-profile-managed-signed-in').disabled = true;
       $('create-profile-managed-signed-in').hidden = true;
       $('create-profile-managed-not-signed-in').hidden = true;
     },
 
     /** @override */
     handleCancel: function() {
       this.cancelCreateProfile_();
     },
 
     /** @override */
-    showErrorBubble_: function(errorText) {
-      ManageProfileOverlay.getInstance().showErrorBubble_(errorText,
+    showErrorBubble_: function(errorHtml) {
+      ManageProfileOverlay.getInstance().showErrorBubble_(errorHtml,
                                                           'create',
                                                           false);
     },
 
     /** @override */
     hideErrorBubble_: function() {
       ManageProfileOverlay.getInstance().hideErrorBubble_('create');
     },
 
     /**
@@ skipping 58 matching lines @@
      *       name: "Profile Name",
      *       filePath: "/path/to/profile/data/on/disk"
      *       isManaged: (true|false),
      *     };
      * @private
      */
     onSuccess_: function(profileInfo) {
       this.updateCreateInProgress_(false);
       OptionsPage.closeOverlay();
       if (profileInfo.isManaged) {
+        options.ManagedUserListData.reloadExistingManagedUsers();
         profileInfo.custodianEmail = this.signedInEmail_;
         ManagedUserCreateConfirmOverlay.setProfileInfo(profileInfo);
         OptionsPage.showPageByName('managedUserCreateConfirm', false);
         BrowserOptions.updateManagesSupervisedUsers(true);
       }
     },
 
     /**
      * Updates the signed-in or not-signed-in UI when in create mode. Called by
      * the handler in response to the 'requestCreateProfileUpdate' message.
@@ skipping 97 matching lines @@
       return instance[name + '_'].apply(instance, arguments);
     };
   });
 
   // Export
   return {
     ManageProfileOverlay: ManageProfileOverlay,
     CreateProfileOverlay: CreateProfileOverlay,
   };
 });