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

chrome/browser/resources/md_user_manager/create_profile.js

 // 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.
 
 /**
  * @fileoverview 'create-profile' is a page that contains controls for creating
  * a (optionally supervised) profile, including choosing a name, and an avatar.
  *
  * @element create-profile
  */
 Polymer({
   is: 'create-profile',
 
-  behaviors: [WebUIListenerBehavior],
+  behaviors: [
+    I18nBehavior,
+    WebUIListenerBehavior
+  ],
 
   properties: {
     /**
-     * True if supervised user checkbox is disabled.
-     * @private {boolean}
-     */
-    supervisedUserCheckboxDisabled_: {
-      type: Boolean,
-      computed:
-          'isSupervisedUserCheckboxDisabled_(createInProgress_, signedIn_)'
-    },
-
-    /**
      * The current profile name.
      * @private {string}
      */
     profileName_: {
       type: String,
-      value: '',
+      value: ''
     },
 
     /**
      * The list of available profile icon URLs.
      * @private {!Array<string>}
      */
     availableIconUrls_: {
       type: Array,
       value: function() { return []; }
     },
@@ skipping 40 matching lines @@
      */
     signedInUsers_: {
       type: Array,
       value: function() { return []; }
     },
 
     /**
      * Index of the selected signed-in user.
      * @private {number}
      */
-    selectedEmail_: {
+    signedInUserIndex_: {
       type: Number,
-      value: 0
+      value: -1 // -1 selects the sentinel item. It means no user is selected.
     },
 
     /** @private {!signin.ProfileBrowserProxy} */
     browserProxy_: Object
   },
 
   /** @override */
   created: function() {
     this.browserProxy_ = signin.ProfileBrowserProxyImpl.getInstance();
   },
 
   /** @override */
-  attached: function() {
-    this.resetForm_();
-
+  ready: function() {
     this.addWebUIListener(
       'create-profile-success', this.handleSuccess_.bind(this));
     this.addWebUIListener(
       'create-profile-warning', this.handleMessage_.bind(this));
     this.addWebUIListener(
       'create-profile-error', this.handleMessage_.bind(this));
     this.addWebUIListener(
       'profile-icons-received', this.handleProfileIcons_.bind(this));
     this.addWebUIListener(
+      'profile-defaults-received', this.handleProfileDefaults_.bind(this));
+    this.addWebUIListener(
       'signedin-users-received', this.handleSignedInUsers_.bind(this));
 
     this.browserProxy_.getAvailableIcons();
     this.browserProxy_.getSignedInUsers();
   },
 
   /**
-   * Resets the state of the page.
-   * @private
-   */
-  resetForm_: function() {
-    this.profileName_ = '';
-    this.availableIconUrls_ = [];
-    this.profileIconUrl_ = '';
-    this.createInProgress_ = false;
-    this.message_ = '';
-    this.isSupervised_ = false;
-    this.signedInUsers_ = [];
-    this.selectedEmail_ = 0;
-  },
-
-  /**
    * Handler for when the profile icons are pushed from the browser.
    * @param {!Array<string>} iconUrls
    * @private
    */
   handleProfileIcons_: function(iconUrls) {
     this.availableIconUrls_ = iconUrls;
     this.profileIconUrl_ = iconUrls[0];
   },
 
   /**
-   * Updates the signed-in users.
+   * Handler for when the profile defaults are pushed from the browser.
+   * @param {ProfileInfo} profileInfo Default Info for the new profile.
+   * @private
+   */
+  handleProfileDefaults_: function(profileInfo) {
+    this.profileName_ = profileInfo.name;
+  },
+
+  /**
+   * Handler for when signed-in users are pushed from the browser.
    * @param {!Array<SignedInUser>} signedInUsers
    * @private
    */
   handleSignedInUsers_: function(signedInUsers) {
     this.signedInUsers_ = signedInUsers;
-    this.signedIn_ = signedInUsers.length > 0;
   },
 
   /**
-   * Handler for the 'Learn More' button click event.
+   * Returns the currently selected signed-in user.
+   * @return {SignedInUser}
+   * @private
+   */
+  signedInUser_: function(signedInUserIndex) {
+    return this.signedInUsers_[signedInUserIndex];
+  },
+
+  /**
+   * Handler for the 'Learn More' link tap event.
    * @param {!Event} event
    * @private
    */
   onLearnMoreTap_: function(event) {
     // TODO(mahmadi): fire the event to show the 'learn-more-page'
   },
 
   /**
-   * Handler for the 'Ok' button click event.
+   * Handler for the 'Save' button tap event.
    * @param {!Event} event
    * @private
    */
   onSaveTap_: function(event) {
     this.createInProgress_ = true;
-    this.browserProxy_.createProfile(
-        this.profileName_, this.profileIconUrl_, this.isSupervised_,
-        this.signedInUsers_[this.selectedEmail_].profilePath);
+
+    var signedInUser = this.signedInUser_(this.signedInUserIndex_);
+
+    if (!this.isSupervised_) {
+      // The new profile is not supervised. Go ahead and create it.
+      this.createProfile_();
+    } else if (!signedInUser) {
+      // If the new profile is supervised, make sure a custodian is selected.
+      this.handleMessage_(this.i18n('custodianAccountNotSelectedError'));
+      this.createInProgress_ = false;
+    } else {
+      this.browserProxy_.getExistingSupervisedUsers(
+          signedInUser.profilePath).then(
+            this.createProfileIfValidSupervisedUser_.bind(this),
+            /** @param {*} error */
+            function(error) { this.handleMessage_(error); }.bind(this));
+    }
   },
 
   /**
-   * Handler for the 'Cancel' button click event.
+   * Checks if the entered name matches name of an existing supervised user.
+   * If yes, the user is prompted to import the existing supervised user.
+   * If no, the new supervised profile gets created.
+   * @param {Array<SupervisedUser>} supervisedUsers The list of existing
+   *     supervised users.
+   * @private
+   */
+  createProfileIfValidSupervisedUser_: function(supervisedUsers) {
+    for (var i = 0; i < supervisedUsers.length; ++i) {
+      if (supervisedUsers[i].name != this.profileName_)
+        continue;
+      // Check if another supervised user also exists with that name.
+      var nameIsUnique = true;
+      // Handling the case when multiple supervised users with the same
+      // name exist, but not all of them are on the device.
+      // If at least one is not imported, we want to offer that
+      // option to the user. This could happen due to a bug that allowed
+      // creating SUs with the same name (https://crbug.com/557445).
+      var allOnCurrentDevice = supervisedUsers[i].onCurrentDevice;
+      for (var j = i + 1; j < supervisedUsers.length; ++j) {
+        if (supervisedUsers[j].name == this.profileName_) {
+          nameIsUnique = false;
+          allOnCurrentDevice = allOnCurrentDevice &&
+             supervisedUsers[j].onCurrentDevice;
+        }
+      }
+
+      this.handleMessage_(allOnCurrentDevice ?
+          this.i18n('managedProfilesExistingLocalSupervisedUser') :
+          this.i18n('manageProfilesExistingSupervisedUser',
+               HTMLEscape(elide(this.profileName_, /* maxLength */ 50))));
+
+      this.createInProgress_ = false;
+      return;
+    }
+    // No existing supervised user's name matches the entered profile name.
+    // Continue with creating the new supervised profile.
+    this.createProfile_();
+  },
+
+  /**
+   * Creates the new profile.
+   * @private
+   */
+  createProfile_: function() {
+    var signedInUser = this.signedInUser_(this.signedInUserIndex_);
+    var custodianProfilePath = signedInUser ? signedInUser.profilePath : '';
+
+    this.browserProxy_.createProfile(
+        this.profileName_, this.profileIconUrl_, this.isSupervised_,
+        custodianProfilePath);
+  },
+
+  /**
+   * Handler for the 'Cancel' button tap event.
    * @param {!Event} event
    * @private
    */
   onCancelTap_: function(event) {
     if (this.createInProgress_) {
       this.createInProgress_ = false;
       this.browserProxy_.cancelCreateProfile();
     } else {
       this.fire('change-page', {page: 'user-pods-page'});
     }
@@ skipping 28 matching lines @@
   },
 
   /**
    * Handles profile create/import warning/error message pushed by the browser.
    * @param {string} message An HTML warning/error message.
    * @private
    */
   handleMessage_: function(message) {
     this.createInProgress_ = false;
     this.message_ = message;
+
+    // TODO(mahmadi): attach handler to '#supervised-user-import-existing'
+    // in order to import supervised user with the given name.
+
+    // TODO(mahmadi): attach handler to '#reauth' in order to re-authenticate
+    // custodian.
   },
 
   /**
    * Computed binding determining which profile icon button is toggled on.
    * @param {string} iconUrl icon URL of a given icon button.
    * @param {string} profileIconUrl Currently selected icon URL.
    * @return {boolean}
    * @private
    */
   isActiveIcon_: function(iconUrl, profileIconUrl) {
     return iconUrl == profileIconUrl;
   },
 
   /**
-   * Computed binding determining whether 'Ok' button is disabled.
+   * Computed binding determining whether 'Save' button is disabled.
    * @param {boolean} createInProgress Is create in progress?
    * @param {string} profileName Profile Name.
-   * @param {string} message Existing warning/error message.
    * @return {boolean}
    * @private
    */
-  isOkDisabled_: function(createInProgress, profileName, message) {
+  isSaveDisabled_: function(createInProgress, profileName) {
     // TODO(mahmadi): Figure out a way to add 'paper-input-extracted' as a
     // dependency and cast to PaperInputElement instead.
     /** @type {{validate: function():boolean}} */
     var nameInput = this.$.nameInput;
-    return createInProgress || !profileName || message != '' ||
-        !nameInput.validate();
+    return createInProgress || !profileName || !nameInput.validate();
   },
 
   /**
-   * Computed binding determining whether supervised user checkbox is disabled.
-   * @param {boolean} createInProgress Is create in progress?
-   * @param {boolean} signedIn Are there any signed-in users?
+   * Computed binding that returns True if there are any signed-in users.
+   * @param {!Array<SignedInUser>} signedInUsers signed-in users.
    * @return {boolean}
    * @private
    */
-  isSupervisedUserCheckboxDisabled_: function(createInProgress, signedIn) {
-    return createInProgress || !signedIn;
+  isSignedIn_: function(signedInUsers) {
+    return signedInUsers.length > 0;
   }
 });