Remove base::StringValue

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 166 matching lines @@
 
   web_ui()->RegisterMessageCallback(
       "requestSignedInProfiles",
       base::Bind(&SigninCreateProfileHandler::RequestSignedInProfiles,
                  base::Unretained(this)));
 }
 
 void SigninCreateProfileHandler::RequestDefaultProfileIcons(
     const base::ListValue* args) {
   web_ui()->CallJavascriptFunctionUnsafe(
-      "cr.webUIListenerCallback", base::StringValue("profile-icons-received"),
+      "cr.webUIListenerCallback", base::Value("profile-icons-received"),
       *profiles::GetDefaultProfileAvatarIconsAndLabels());
 
   SendNewProfileDefaults();
 }
 
 void SigninCreateProfileHandler::SendNewProfileDefaults() {
   ProfileAttributesStorage& storage =
       g_browser_process->profile_manager()->GetProfileAttributesStorage();
   base::DictionaryValue profile_info;
   profile_info.SetString("name", storage.ChooseNameForNewProfile(0));
 
   web_ui()->CallJavascriptFunctionUnsafe(
-      "cr.webUIListenerCallback",
-      base::StringValue("profile-defaults-received"), profile_info);
+      "cr.webUIListenerCallback", base::Value("profile-defaults-received"),
+      profile_info);
 }
 
 void SigninCreateProfileHandler::RequestSignedInProfiles(
     const base::ListValue* args) {
   base::ListValue user_info_list;
   std::vector<ProfileAttributesEntry*> entries =
       g_browser_process->profile_manager()->
           GetProfileAttributesStorage().GetAllProfilesAttributesSortedByName();
   for (ProfileAttributesEntry* entry : entries) {
     base::string16 username = entry->GetUserName();
     if (username.empty())
       continue;
     base::string16 profile_path = entry->GetPath().AsUTF16Unsafe();
     std::unique_ptr<base::DictionaryValue> user_info(
         new base::DictionaryValue());
     user_info->SetString("username", username);
     user_info->SetString("profilePath", profile_path);
 
     user_info_list.Append(std::move(user_info));
   }
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "cr.webUIListenerCallback", base::StringValue("signedin-users-received"),
-      user_info_list);
+  web_ui()->CallJavascriptFunctionUnsafe("cr.webUIListenerCallback",
+                                         base::Value("signedin-users-received"),
+                                         user_info_list);
 }
 
 void SigninCreateProfileHandler::OnProfileAuthInfoChanged(
     const base::FilePath& profile_path) {
   RequestSignedInProfiles(nullptr);
 }
 
 void SigninCreateProfileHandler::CreateProfile(const base::ListValue* args) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
@@ skipping 197 matching lines @@
   UserManagerProfileDialog::ShowSigninDialog(
       web_ui()->GetWebContents()->GetBrowserContext(), profile->GetPath());
 }
 
 void SigninCreateProfileHandler::ShowProfileCreationError(
     Profile* profile,
     const base::string16& error) {
   DCHECK_NE(NO_CREATION_IN_PROGRESS, profile_creation_type_);
   web_ui()->CallJavascriptFunctionUnsafe(
       "cr.webUIListenerCallback", GetWebUIListenerName(PROFILE_CREATION_ERROR),
-      base::StringValue(error));
+      base::Value(error));
   // The ProfileManager calls us back with a NULL profile in some cases.
   if (profile) {
     webui::DeleteProfileAtPath(profile->GetPath(),
                                web_ui(),
                                ProfileMetrics::DELETE_PROFILE_SETTINGS);
   }
   profile_creation_type_ = NO_CREATION_IN_PROGRESS;
   profile_path_being_created_.clear();
 }
 
@@ skipping 37 matching lines @@
   // Chrome to close.
   if (browser && browser->window()) {
     UserManager::Hide();
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }
 
-base::StringValue SigninCreateProfileHandler::GetWebUIListenerName(
+base::Value SigninCreateProfileHandler::GetWebUIListenerName(
     ProfileCreationStatus status) const {
   switch (status) {
     case PROFILE_CREATION_SUCCESS:
-      return base::StringValue("create-profile-success");
+      return base::Value("create-profile-success");
     case PROFILE_CREATION_ERROR:
-      return base::StringValue("create-profile-error");
+      return base::Value("create-profile-error");
   }
   NOTREACHED();
-  return base::StringValue(std::string());
+  return base::Value(std::string());
 }
 
 #if BUILDFLAG(ENABLE_SUPERVISED_USERS)
 base::string16 SigninCreateProfileHandler::GetProfileCreateErrorMessageRemote()
     const {
   return l10n_util::GetStringUTF16(
       profile_creation_type_ == SUPERVISED_PROFILE_IMPORT
           ? IDS_LEGACY_SUPERVISED_USER_IMPORT_REMOTE_ERROR
           : IDS_PROFILES_CREATE_REMOTE_ERROR);
 }
@@ skipping 241 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()->CallJavascriptFunctionUnsafe(
-      "cr.webUIListenerCallback", base::StringValue("create-profile-warning"),
-      base::StringValue(warning));
+  web_ui()->CallJavascriptFunctionUnsafe("cr.webUIListenerCallback",
+                                         base::Value("create-profile-warning"),
+                                         base::Value(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_);
@@ skipping 24 matching lines @@
 
   profiles::OpenBrowserWindowForProfile(
       base::Bind(&SigninCreateProfileHandler::OnBrowserReadyCallback,
                  weak_ptr_factory_.GetWeakPtr()),
       false,  // Don't create a window if one already exists.
       true,  // Create a first run window.
       profile,
       Profile::CREATE_STATUS_INITIALIZED);
 }
 #endif