MD user manager (html/js/css for create profile flow)

chrome/browser/resources/md_user_manager/profile_api.js

Index: chrome/browser/resources/md_user_manager/profile_api.js
diff --git a/chrome/browser/resources/md_user_manager/profile_api.js b/chrome/browser/resources/md_user_manager/profile_api.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6099d565f545e36b397efe8e22699b0ade4871f
--- /dev/null
+++ b/chrome/browser/resources/md_user_manager/profile_api.js
@@ -0,0 +1,139 @@
+// 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.
+
+/** @typedef {{username: string, profilePath: string}} */
+var SignedInUser;
+
+/** @typedef {{name: string, filePath: string, isSupervised: boolean}} */
+var ProfileInfo;
+
+cr.define('signin.ProfileApi', function() {
+  /**
+   * API that encapsulates messaging between JS and C++ for creating/importing
+   * profiles in the user-manager page.
+   */
+  return {

[Dan Beam, 2016/03/02 23:19:24]

why is this better than the previous code?

the code in earlier patchsets more closely mirrors the typical webui convention

[Moe, 2016/03/03 18:05:46]

IMO this is cleaner and less verbose. 'cr.define' expects a callback function
which returns an object containing names and values of the fields. This is
closer to it that than returning a function object with properties defined on
it. Also in the current convention (as in e.g.,
settings/people_page/sync_private_api.js) callbacks are being set on the
function object not the resulting object instance which seems more intuitive.

PS. I still don't quite understand what I need to do with the callbacks. From
what I understand callbacks need to be stored somewhere. Is storing them at all
what's wrong with this code? 

[Dan Beam, 2016/03/04 02:45:48]

if you really want "cleanest" and don't want to do

  cr.define('signin', function() {
    ... defined ProfileApi ...
    return {ProfileApi: ProfileApi};
  });

you can do

  cr.exportPath('signin');

  signin.ProfileApi = function() {};

  signin.ProfileApi.prototype = {
    ...
  };

BUT we have specific logic in our closure compiler pass that looks for the
cr.define() pattern (and I don't see a utility to supporting another format if
your new code doesn't compile)
I would recommend not using globals, whether or not they're bound to namespaced,
static context or not.  The old code is was a bummer like that, but not bad
enough to immediately rewrite.  We will likely rewrite it while porting to
Material Design settings.

I'm sorry you've hit so many landmines.
yes, it's very hard to test (especially asynchronously) and probably acts
unexpectedly when called from multiple sources

+    /**
+     * Sets the profile create success callback.
+     * @param {?function(!ProfileInfo)} callback
+     */
+    setProfileCreateSuccessCallback: function(callback) {
+      this.profileCreateSuccessCallback_ = callback;
+    },
+
+    /**
+     * Sets the profile create warning callback.
+     * @param {?function(!string)} callback
+     */
+    setProfileCreateWarningCallback: function(callback) {
+      this.profileCreateWarningCallback_ = callback;
+    },
+
+    /**
+     * Sets the profile create error callback.
+     * @param {?function(!string)} callback
+     */
+    setProfileCreateErrorCallback: function(callback) {
+      this.profileCreateErrorCallback_ = callback;
+    },
+
+    /**
+     * Called from JavaScript. Gets the available profile icons.
+     * @param {!function(!Array<string>)} callback
+     */
+    getAvailableIcons: function(callback) {
+      this.getAvailableIconsCallback_ = callback;
+      chrome.send('requestDefaultProfileIcons');
+    },
+
+    /**
+     * Called from JavaScript. Gets the current signed-in users.
+     * @param {!function(!Array<SignedInUser>)} callback
+     */
+    getSignedInUsers: function(callback) {
+      this.getSignedInUsersCallback_ = callback;
+      chrome.send('requestSignedInProfiles');
+    },
+
+    /**
+     * Called from JavaScript. Launches the guest user.
+     */
+    launchGuestUser: function() {
+      chrome.send('launchGuest');
+    },
+
+    /**
+     * Called from JavaScript. Creates a profile.
+     * @param {string} profileName Name of the new profile.
+     * @param {string} profileIconUrl URL of the selected profile icon.
+     * @param {boolean} isSupervised True if the new profile is supervised.
+     * @param {(string|undefined)} supervisorProfilePath Profile path of the
+     * supervisor if the new profile is supervised.
+     */
+    createProfile: function(profileName, profileIconUrl, isSupervised,
+          supervisorProfilePath) {
+      chrome.send('createProfile',
+                  [profileName, profileIconUrl, false, isSupervised, '',
+                   supervisorProfilePath]);
+    },
+
+    /**
+     * Called from JavaScript. Cancels creation of the new profile.
+     */
+    cancelCreateProfile: function() {
+      chrome.send('cancelCreateProfile');
+    },
+
+    /**
+     * Called from C++ as a response to getAvailableIcons.
+     * @param {!Array<string>} iconUrls An array of icon URLs.
+     * @private
+     */
+    updateAvailableIcons: function(iconUrls) {
+      if (this.getAvailableIconsCallback_)
+        this.getAvailableIconsCallback_(iconUrls);
+    },
+
+    /**
+     * Called from C++ in response to 'requestSignedInProfiles'.
+     * @param {!Array<SignedInUser>} signedInUsers An array of email addresses
+     * of signed in users and the corresponding profile path.
+     * @private
+     */
+    updateSignedInUsers: function(signedInUsers) {
+      if (this.getSignedInUsersCallback_)
+        this.getSignedInUsersCallback_(signedInUsers);
+    },
+
+    /**
+     * Called from C++ to report supervised profile create errors.
+     * @param {string} error The error raised while creating a profile.
+     * @private
+     */
+    onCreateProfileError: function(error) {
+      if (this.profileCreateErrorCallback_)
+        this.profileCreateErrorCallback_(error);
+    },
+
+    /**
+     * Called from C++ to report supervised profile create warnings.
+     * @param {string} warning The warning issued while creating a profile.
+     * @private
+     */
+    onCreateProfileWarning: function(warning) {
+      if (this.profileCreateWarningCallback_)
+        this.profileCreateWarningCallback_(warning);
+    },
+
+    /**
+     * Called from C++ to report successful creation of a profile.
+     * @param {!ProfileInfo} profileInfo
+     * @private
+     */
+    onCreateProfileSuccess: function(profileInfo) {
+      if (this.profileCreateSuccessCallback_)
+        this.profileCreateSuccessCallback_(profileInfo);
+    }
+  };
+});