Add error handling for supervised user import flow.

chrome/browser/resources/options/managed_user_import.js

 // Copyright 2013 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;
 
   /**
+   * ManagedUserList class.

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

I'd suggest moving this into its own file.

[Adrian Kuegel, 2014/01/08 12:51:47]

Yes, I thought about that, but I guess I should then rename this class, because
a managed_user_list.js file already exists which handles the ui part of the list
of existing supervised users. Maybe ManagedUserCache would be ok?

[Pam (message me for reviews), 2014/01/08 14:36:45]

Oh boy, what a batch of confusing class names. Oh well -- ManagedUserCache
sounds good. Or maybe ManagedUserDataModel, ManagedUserListData,
ManagedUserListModel?

[Adrian Kuegel, 2014/01/08 16:49:08]

I decided to use ManagedUserListData now.

+   * Handles requests for retrieving a list of existing managed users which are
+   * supervised by the current profile. This list is cached in order to make it
+   * possible to serve future requests immediately. The first request will be

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

Are we concerned about the cache becoming stale, e.g. if the user creates a new
SU in another instance of Chrome after this has been loaded?

[Adrian Kuegel, 2014/01/08 12:51:47]

Yes, I think we should handle that. I think we could add a notification for this
event. Then we would not have to load the list each time, but the list is
updated when there are changes.
Would it be ok for you if I delay this to a future CL?

[Pam (message me for reviews), 2014/01/08 14:36:45]

Yes, since the failure case (managing to create a new SU with the same name as
an existing one) isn't horrible for the short term; it's exactly what we have
now.

An easy improvement would be to update the cached list when a new SU is created
locally. That could happen entirely within JS.

[Adrian Kuegel, 2014/01/08 16:49:08]

Ok, makes sense. Otherwise I think the import dialog would still allow to import
the supervised user that just got imported.
I added a function which will just reload the list. This seemed to be the
easiest way.
This will not handle the case that you have two settings pages open at the same
time, but at least now the list in the same settings page will be updated after
a supervised user profile is deleted or created.

+   * handled asynchronously.
+   * @constructor
+   * @class
+   */
+  function ManagedUserList() {
+    this.callbacks_ = [];
+    this.errbacks_ = [];
+    this.requestInProgress_ = false;
+    this.managedUsers = null;
+  };
+
+  cr.addSingletonGetter(ManagedUserList);
+
+  /**
+   * Resets to the initial state of no pending requests.
+   * @private
+   */
+  ManagedUserList.prototype.reset_ = function() {
+    this.callbacks_ = [];
+    this.errbacks_ = [];
+    this.requestInProgress_ = false;
+  }
+
+  /**
+   * Receives a list of managed users.

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

and passes the list to each of the callbacks.

[Adrian Kuegel, 2014/01/08 12:51:47]

Done.

+   * @param {Array.<Object>} managedUsers An array of managed user objects.
+   *     Each object is of the form:
+   *       managedUser = {
+   *         id: "Managed User ID",
+   *         name: "Managed User Name",
+   *         iconURL: "chrome://path/to/icon/image",
+   *         onCurrentDevice: true or false,
+   *         needAvatar: true or false
+   *       }
+   */
+  ManagedUserList.receiveExistingManagedUsers = function(managedUsers) {
+    var instance = ManagedUserList.getInstance();
+    var i;
+    for (i = 0; i < instance.callbacks_.length; i++) {
+      instance.callbacks_[i](managedUsers);
+    }
+    this.managedUsers = managedUsers;
+    instance.reset_();
+  };
+
+  /**
+   * Called when there is a signin error when retrieving the list of managed
+   * users. Calls the error callbacks which will display an appropriate error
+   * message to the user.
+   */
+  ManagedUserList.onSigninError = function() {
+    var instance = ManagedUserList.getInstance();
+    var i;
+    for (i = 0; i < instance.errbacks_.length; i++) {
+      instance.errbacks_[i]();
+    }
+    // Reset the list of managed users in order to avoid showing stale data.
+    instance.managedUsers = null;
+    instance.reset_();
+  };
+
+  /**
+   * Handles the request for the list of existing managed users. If the data is
+   * already available, it will call |callback| immediately. Otherwise, it
+   * retrieves the list of existing managed users which is then processed in
+   * receiveExistingManagedUsers().
+   * @param {Object} callback The callback function which is called on success.
+   * @param {Object} errback the callback function which is called on error.
+   */
+  ManagedUserList.requestExistingManagedUsers = function(callback, errback) {
+    var instance = ManagedUserList.getInstance();
+    instance.callbacks_.push(callback);
+    instance.errbacks_.push(errback);
+    if (!instance.requestInProgress_) {
+      if (instance.managedUsers != null) {
+        ManagedUserList.receiveExistingManagedUsers(instance.managedUsers);
+        return;
+      }
+      instance.requestInProgress_ = true;
+      chrome.send('requestManagedUserImportUpdate');
+    }
+  };
+
+  /**
    * ManagedUserImportOverlay class.
    * Encapsulated handling of the 'Import existing managed user' overlay page.
    * @constructor
    * @class
    */
   function ManagedUserImportOverlay() {
     var title = loadTimeData.getString('managedUserImportTitle');
     OptionsPage.call(this, 'managedUserImport',
                      title, 'managed-user-import');
   };
@@ skipping 48 matching lines @@
       $('create-new-user-link').onclick = function(event) {
         OptionsPage.closeOverlay();
         OptionsPage.navigateToPage('createProfile');
       };
     },
 
     /**
      * @override
      */
     didShowPage: function() {
-      chrome.send('requestManagedUserImportUpdate');
+      ManagedUserList.requestExistingManagedUsers(
+          this.receiveExistingManagedUsers_, this.onSigninError_.bind(this));
 
       this.updateImportInProgress_(false);
       $('managed-user-import-error-bubble').hidden = true;
       $('managed-user-import-ok').disabled = true;
       $('select-avatar-grid').hidden = true;
       $('managed-user-list').hidden = false;
 
       $('managed-user-import-ok').textContent =
           loadTimeData.getString('managedUserImportOk');
       $('managed-user-import-text').textContent =
@@ skipping 61 matching lines @@
      */
     updateImportInProgress_: function(inProgress) {
       $('managed-user-import-ok').disabled = inProgress;
       $('managed-user-list').disabled = inProgress;
       $('select-avatar-grid').disabled = inProgress;
       $('create-new-user-link').disabled = inProgress;
       $('managed-user-import-throbber').hidden = !inProgress;
     },
 
     /**
-     * Adds all the existing |managedUsers| to the list. If |managedUsers|
-     * is undefined, then the list is cleared.
+     * Sets the data model of the managed user list to |managedUsers|.
      * @param {Array.<Object>} managedUsers An array of managed user objects.
      *     Each object is of the form:
      *       managedUser = {
      *         id: "Managed User ID",
      *         name: "Managed User Name",
      *         iconURL: "chrome://path/to/icon/image",
      *         onCurrentDevice: true or false,
      *         needAvatar: true or false
      *       }
      * @private
      */
     receiveExistingManagedUsers_: function(managedUsers) {
-      if (!managedUsers) {
-        $('managed-user-list').dataModel = null;
-        return;
-      }
-
       managedUsers.sort(function(a, b) {
         return a.name.localeCompare(b.name);
       });
 
       $('managed-user-list').dataModel = new ArrayDataModel(managedUsers);
       if (managedUsers.length == 0) {
         this.onError_(loadTimeData.getString('noExistingManagedUsers'));
         $('managed-user-import-ok').disabled = true;
+      } else {
+        // Hide the error bubble.
+        $('managed-user-import-error-bubble').hidden = true;
       }
     },
 
-    /**
-     * @private
-     */
-    hideErrorBubble_: function() {
-      $('managed-user-import-error-bubble').hidden = true;
+    onSigninError_: function() {
+      $('managed-user-list').dataModel = null;
+      this.onError_(loadTimeData.getString('managedUserImportSigninError'));
     },
 
     /**
      * Displays an error message if an error occurs while
      * importing a managed user.
      * Called by BrowserOptions via the BrowserOptionsHandler.
      * @param {string} error The error message to display.
      * @private
      */
     onError_: function(error) {
       var errorBubble = $('managed-user-import-error-bubble');
       errorBubble.hidden = false;
       errorBubble.textContent = error;
       this.updateImportInProgress_(false);
     },
 
     /**
      * Closes the overlay if importing the managed user was successful.
      * @private
      */
     onSuccess_: function() {
       this.updateImportInProgress_(false);
       OptionsPage.closeOverlay();
     },
   };
 
   // Forward public APIs to private implementations.
   [
-    'hideErrorBubble',
-    'onError',
     'onSuccess',
-    'receiveExistingManagedUsers',
   ].forEach(function(name) {
     ManagedUserImportOverlay[name] = function() {
       var instance = ManagedUserImportOverlay.getInstance();
       return instance[name + '_'].apply(instance, arguments);
     };
   });
 
   // Export
   return {
     ManagedUserImportOverlay: ManagedUserImportOverlay,
+    ManagedUserList: ManagedUserList,
   };
 });