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

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>
 
@@ skipping 39 matching lines @@
 SigninCreateProfileHandler::~SigninCreateProfileHandler() {
 #if defined(ENABLE_SUPERVISED_USERS)
   // Cancellation is only supported for supervised users.
   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));
@@ skipping 42 matching lines @@
 
   // Add the default avatar icons.
   size_t placeholder_avatar_index = profiles::GetPlaceholderAvatarIndex();
   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("signin.ProfileApi.updateAvailableIcons",
+  web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
+                                   base::StringValue("profile-icons-received"),
                                    image_url_list);
 }
 
 void SigninCreateProfileHandler::RequestSignedInProfiles(
     const base::ListValue* args) {
   base::ListValue user_info_list;
   ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
   std::vector<ProfileAttributesEntry*> entries =
       cache.GetAllProfilesAttributes();
   for (auto& entry : entries) {
     base::string16 username = entry->GetUserName();
     if (username.empty())
       continue;
     base::string16 profile_path = entry->GetPath().AsUTF16Unsafe();
     scoped_ptr<base::DictionaryValue> user_info(new base::DictionaryValue());
     user_info->SetString("username", username);
     user_info->SetString("profilePath", profile_path);
 
     user_info_list.Append(user_info.release());
   }
-  web_ui()->CallJavascriptFunction("signin.ProfileApi.updateSignedInUsers",
+  web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
+                                   base::StringValue("signedin-users-received"),
                                    user_info_list);
 }
 
 void SigninCreateProfileHandler::CreateProfile(const base::ListValue* args) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 
   // We can have only one in progress profile creation
   // at any given moment, if new ones are initiated just
   // ignore them until we are done with the old one.
@@ skipping 130 matching lines @@
   DCHECK_NE(NO_CREATION_IN_PROGRESS, profile_creation_type_);
   base::DictionaryValue dict;
   dict.SetString("name", profile->GetPrefs()->GetString(prefs::kProfileName));
   dict.Set("filePath", base::CreateFilePathValue(profile->GetPath()));
 #if defined(ENABLE_SUPERVISED_USERS)
   bool is_supervised = profile_creation_type_ == SUPERVISED_PROFILE_CREATION ||
                        profile_creation_type_ == SUPERVISED_PROFILE_IMPORT;
   dict.SetBoolean("isSupervised", is_supervised);
 #endif
   web_ui()->CallJavascriptFunction(
-      GetJavascriptMethodName(PROFILE_CREATION_SUCCESS), dict);
+      "cr.webUIListenerCallback",
+      GetWebUIListenerName(PROFILE_CREATION_SUCCESS),
+      dict);
 
   // If the new profile is a supervised user, instead of opening a new window
   // right away, a confirmation overlay will be shown by JS from the creation
   // dialog. If we are importing an existing supervised profile or creating a
   // new non-supervised user profile we don't show any confirmation, so open
   // the new window now.
   bool should_open_new_window = true;
 #if defined(ENABLE_SUPERVISED_USERS)
   if (profile_creation_type_ == SUPERVISED_PROFILE_CREATION)
     should_open_new_window = false;
 #endif
 
   if (should_open_new_window) {
     // Opening the new window must be the last action, after all callbacks
     // have been run, to give them a chance to initialize the profile.
     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(
-      GetJavascriptMethodName(PROFILE_CREATION_ERROR),
-      base::StringValue(error));
+  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());
 }
 
 void SigninCreateProfileHandler::RecordProfileCreationMetrics(
     Profile::CreateStatus status) {
   UMA_HISTOGRAM_ENUMERATION("Profile.CreateResult", status,
                             Profile::MAX_CREATE_STATUS);
   UMA_HISTOGRAM_MEDIUM_TIMES(
@@ skipping 23 matching lines @@
 
 base::string16 SigninCreateProfileHandler::GetProfileCreateErrorMessageSignin()
     const {
   return l10n_util::GetStringUTF16(
       profile_creation_type_ == SUPERVISED_PROFILE_IMPORT
           ? IDS_LEGACY_SUPERVISED_USER_IMPORT_SIGN_IN_ERROR
           : IDS_PROFILES_CREATE_SIGN_IN_ERROR);
 }
 #endif
 
-std::string SigninCreateProfileHandler::GetJavascriptMethodName(
+base::StringValue SigninCreateProfileHandler::GetWebUIListenerName(
     ProfileCreationStatus status) const {
   switch (profile_creation_type_) {
 #if defined(ENABLE_SUPERVISED_USERS)
     case SUPERVISED_PROFILE_IMPORT:
       switch (status) {
         case PROFILE_CREATION_SUCCESS:
-          return "BrowserOptions.showSupervisedUserImportSuccess";
+          return base::StringValue("create-profile-success");
         case PROFILE_CREATION_ERROR:
-          return "BrowserOptions.showSupervisedUserImportError";
+          return base::StringValue("create-profile-error");
       }
       break;
 #endif
     default:
       switch (status) {
         case PROFILE_CREATION_SUCCESS:
-          return "signin.ProfileApi.onCreateProfileSuccess";
+          return base::StringValue("create-profile-success");
         case PROFILE_CREATION_ERROR:
-          return "signin.ProfileApi.onCreateProfileError";
+          return base::StringValue("create-profile-error");
       }
       break;
   }
 
   NOTREACHED();
-  return std::string();
+  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) {
   bool supervised_user = false;
   bool success = args->GetBoolean(3, &supervised_user);
   DCHECK(success);
@@ skipping 186 matching lines @@
     error_msg = GetProfileCreateErrorMessageSignin();
   } else {
     error_msg = GetProfileCreateErrorMessageRemote();
   }
   ShowProfileCreationError(profile, error_msg);
 }
 
 void SigninCreateProfileHandler::ShowProfileCreationWarning(
     const base::string16& warning) {
   DCHECK_EQ(SUPERVISED_PROFILE_CREATION, profile_creation_type_);
-  web_ui()->CallJavascriptFunction("signin.ProfileApi.onCreateProfileWarning",
+  web_ui()->CallJavascriptFunction("cr.webUIListenerCallback",
+                                   base::StringValue("create-profile-warning"),
                                    base::StringValue(warning));
 }
 
 void SigninCreateProfileHandler::RecordSupervisedProfileCreationMetrics(
     GoogleServiceAuthError::State error_state) {
   if (profile_creation_type_ == SUPERVISED_PROFILE_CREATION) {
     UMA_HISTOGRAM_ENUMERATION("Profile.SupervisedProfileCreateError",
                               error_state, GoogleServiceAuthError::NUM_STATES);
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "Profile.SupervisedProfileTotalCreateTime",
         base::TimeTicks::Now() - profile_creation_start_time_);
   } else {
     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