Remove base::StringValue

chrome/browser/ui/webui/signin/user_manager_screen_handler.cc

 // 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.
 
 #include "chrome/browser/ui/webui/signin/user_manager_screen_handler.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 304 matching lines @@
   }
 }
 
 UserManagerScreenHandler::~UserManagerScreenHandler() {
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(NULL);
 }
 
 void UserManagerScreenHandler::ShowBannerMessage(
     const base::string16& message) {
   web_ui()->CallJavascriptFunctionUnsafe(
-      "login.AccountPickerScreen.showBannerMessage",
-      base::StringValue(message));
+      "login.AccountPickerScreen.showBannerMessage", base::Value(message));
 }
 
 void UserManagerScreenHandler::ShowUserPodCustomIcon(
     const AccountId& account_id,
     const proximity_auth::ScreenlockBridge::UserPodCustomIconOptions&
         icon_options) {
   std::unique_ptr<base::DictionaryValue> icon =
       icon_options.ToDictionaryValue();
   if (!icon || icon->empty())
     return;
   web_ui()->CallJavascriptFunctionUnsafe(
       "login.AccountPickerScreen.showUserPodCustomIcon",
-      base::StringValue(account_id.GetUserEmail()), *icon);
+      base::Value(account_id.GetUserEmail()), *icon);
 }
 
 void UserManagerScreenHandler::HideUserPodCustomIcon(
     const AccountId& account_id) {
   web_ui()->CallJavascriptFunctionUnsafe(
       "login.AccountPickerScreen.hideUserPodCustomIcon",
-      base::StringValue(account_id.GetUserEmail()));
+      base::Value(account_id.GetUserEmail()));
 }
 
 void UserManagerScreenHandler::EnableInput() {
   // Nothing here because UI is not disabled when starting to authenticate.
 }
 
 void UserManagerScreenHandler::SetAuthType(
     const AccountId& account_id,
     proximity_auth::ScreenlockBridge::LockHandler::AuthType auth_type,
     const base::string16& auth_value) {
   if (GetAuthType(account_id) ==
       proximity_auth::ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD)
     return;
 
   user_auth_type_map_[account_id.GetUserEmail()] = auth_type;
   web_ui()->CallJavascriptFunctionUnsafe(
       "login.AccountPickerScreen.setAuthType",
-      base::StringValue(account_id.GetUserEmail()), base::Value(auth_type),
-      base::StringValue(auth_value));
+      base::Value(account_id.GetUserEmail()), base::Value(auth_type),
+      base::Value(auth_value));
 }
 
 proximity_auth::ScreenlockBridge::LockHandler::AuthType
 UserManagerScreenHandler::GetAuthType(const AccountId& account_id) const {
   const auto it = user_auth_type_map_.find(account_id.GetUserEmail());
   if (it == user_auth_type_map_.end())
     return proximity_auth::ScreenlockBridge::LockHandler::OFFLINE_PASSWORD;
   return it->second;
 }
 
@@ skipping 117 matching lines @@
   base::FilePath profile_path;
   if (!base::GetValueAsFilePath(*profile_path_value, &profile_path)) {
     NOTREACHED();
     return;
   }
 
   DCHECK(profiles::IsMultipleProfilesEnabled());
 
   if (profiles::AreAllNonChildNonSupervisedProfilesLocked()) {
     web_ui()->CallJavascriptFunctionUnsafe(
-        "cr.webUIListenerCallback",
-        base::StringValue("show-error-dialog"),
-        base::StringValue(l10n_util::GetStringUTF8(
+        "cr.webUIListenerCallback", base::Value("show-error-dialog"),
+        base::Value(l10n_util::GetStringUTF8(
             IDS_USER_MANAGER_REMOVE_PROFILE_PROFILES_LOCKED_ERROR)));
     return;
   }
 
   // The callback is run if the only profile has been deleted, and a new
   // profile has been created to replace it.
   webui::DeleteProfileAtPath(profile_path,
                              web_ui(),
                              ProfileMetrics::DELETE_PROFILE_USER_MANAGER);
 }
@@ skipping 12 matching lines @@
 
 void UserManagerScreenHandler::HandleAreAllProfilesLocked(
     const base::ListValue* args) {
   std::string webui_callback_id;
   CHECK_EQ(1U, args->GetSize());
   bool success = args->GetString(0, &webui_callback_id);
   DCHECK(success);
 
   AllowJavascript();
   ResolveJavascriptCallback(
-      base::StringValue(webui_callback_id),
+      base::Value(webui_callback_id),
       base::Value(profiles::AreAllNonChildNonSupervisedProfilesLocked()));
 }
 
 void UserManagerScreenHandler::HandleLaunchUser(const base::ListValue* args) {
   const base::Value* profile_path_value = NULL;
   if (!args->Get(0, &profile_path_value))
     return;
 
   base::FilePath profile_path;
   if (!base::GetValueAsFilePath(*profile_path_value, &profile_path))
@@ skipping 47 matching lines @@
   const base::Value* profile_path_value;
 
   if (!args->Get(0, &profile_path_value))
     return;
 
   base::FilePath profile_path;
 
   if (!base::GetValueAsFilePath(*profile_path_value, &profile_path))
     return;
 
-  base::StringValue return_profile_path(profile_path.value());
+  base::Value return_profile_path(profile_path.value());
   Profile* profile = g_browser_process->profile_manager()->
       GetProfileByPath(profile_path);
 
   if (!profile)
     return;
 
   if (!chrome::FindAnyBrowser(profile, true)) {
     // If no windows are open for that profile, the statistics in
     // ProfileAttributesStorage are up to date. The statistics in
     // ProfileAttributesStorage are returned because the copy in user_pod_row.js
     // may be outdated. However, if some statistics are missing in
     // ProfileAttributesStorage (i.e. |item.success| is false), then the actual
     // statistics are queried instead.
     base::DictionaryValue return_value;
     profiles::ProfileCategoryStats stats =
         ProfileStatistics::GetProfileStatisticsFromAttributesStorage(
             profile_path);
     bool stats_success = true;
     for (const auto& item : stats) {
       std::unique_ptr<base::DictionaryValue> stat(new base::DictionaryValue);
       stat->SetIntegerWithoutPathExpansion("count", item.count);
       stat->SetBooleanWithoutPathExpansion("success", item.success);
       return_value.SetWithoutPathExpansion(item.category, std::move(stat));
       stats_success &= item.success;
     }
     if (stats_success) {
-      web_ui()->CallJavascriptFunctionUnsafe(
-          "updateRemoveWarningDialog", base::StringValue(profile_path.value()),
-          return_value);
+      web_ui()->CallJavascriptFunctionUnsafe("updateRemoveWarningDialog",
+                                             base::Value(profile_path.value()),
+                                             return_value);
       return;
     }
   }
 
   ProfileStatisticsFactory::GetForProfile(profile)->GatherStatistics(
       base::Bind(
           &UserManagerScreenHandler::RemoveUserDialogLoadStatsCallback,
           weak_ptr_factory_.GetWeakPtr(), profile_path));
 }
 
 void UserManagerScreenHandler::RemoveUserDialogLoadStatsCallback(
     base::FilePath profile_path,
     profiles::ProfileCategoryStats result) {
   // Copy result into return_value.
   base::DictionaryValue return_value;
   for (const auto& item : result) {
     std::unique_ptr<base::DictionaryValue> stat(new base::DictionaryValue);
     stat->SetIntegerWithoutPathExpansion("count", item.count);
     stat->SetBooleanWithoutPathExpansion("success", item.success);
     return_value.SetWithoutPathExpansion(item.category, std::move(stat));
   }
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "updateRemoveWarningDialog", base::StringValue(profile_path.value()),
-      return_value);
+  web_ui()->CallJavascriptFunctionUnsafe("updateRemoveWarningDialog",
+                                         base::Value(profile_path.value()),
+                                         return_value);
 }
 
 void UserManagerScreenHandler::HandleGetRemoveWarningDialogMessage(
     const base::ListValue* args) {
   const base::DictionaryValue* arg;
   if (!args->GetDictionary(0, &arg))
     return;
 
   std::string profile_path("");
   bool is_synced_user = false;
   bool has_errors = false;
 
   if (!arg->GetString("profilePath", &profile_path) ||
       !arg->GetBoolean("isSyncedUser", &is_synced_user) ||
       !arg->GetBoolean("hasErrors", &has_errors))
     return;
 
   int total_count = 0;
   if (!arg->GetInteger("totalCount", &total_count))
     return;
 
   int message_id = is_synced_user ?
       (has_errors ? IDS_LOGIN_POD_USER_REMOVE_WARNING_SYNC_WITH_ERRORS :
                     IDS_LOGIN_POD_USER_REMOVE_WARNING_SYNC) :
       (has_errors ? IDS_LOGIN_POD_USER_REMOVE_WARNING_NONSYNC_WITH_ERRORS :
                     IDS_LOGIN_POD_USER_REMOVE_WARNING_NONSYNC);
 
-  base::StringValue message = base::StringValue(
-      l10n_util::GetPluralStringFUTF16(message_id, total_count));
+  base::Value message =
+      base::Value(l10n_util::GetPluralStringFUTF16(message_id, total_count));
 
   web_ui()->CallJavascriptFunctionUnsafe("updateRemoveWarningDialogSetMessage",
-                                         base::StringValue(profile_path),
-                                         message, base::Value(total_count));
+                                         base::Value(profile_path), message,
+                                         base::Value(total_count));
 }
 
 void UserManagerScreenHandler::OnGetTokenInfoResponse(
     std::unique_ptr<base::DictionaryValue> token_info) {
   // Password is unchanged so user just mistyped it.  Ask again.
   ReportAuthenticationResult(false, ProfileMetrics::AUTH_FAILED);
 }
 
 void UserManagerScreenHandler::OnOAuthError() {
   // Password has changed.  Go through online signin flow.
@@ skipping 288 matching lines @@
 
   if (success) {
     profiles::SwitchToProfile(
         authenticating_profile_path_, true,
         base::Bind(&UserManagerScreenHandler::OnSwitchToProfileComplete,
                    weak_ptr_factory_.GetWeakPtr()),
         ProfileMetrics::SWITCH_PROFILE_UNLOCK);
   } else {
     web_ui()->CallJavascriptFunctionUnsafe(
         "cr.ui.UserManager.showSignInError", base::Value(0),
-        base::StringValue(l10n_util::GetStringUTF8(
+        base::Value(l10n_util::GetStringUTF8(
             auth == ProfileMetrics::AUTH_FAILED_OFFLINE
                 ? IDS_LOGIN_ERROR_AUTHENTICATING_OFFLINE
                 : IDS_LOGIN_ERROR_AUTHENTICATING)),
-        base::StringValue(""), base::Value(0));
+        base::Value(""), base::Value(0));
   }
 }
 
 void UserManagerScreenHandler::OnBrowserWindowReady(Browser* browser) {
   DCHECK(browser);
   DCHECK(browser->window());
 
   // Unlock the profile after browser opens so startup can read the lock bit.
   // Any necessary authentication must have been successful to reach this point.
   if (!browser->profile()->IsGuestSession()) {
@@ skipping 37 matching lines @@
     Profile* profile, Profile::CreateStatus profile_create_status) {
   Browser* browser = chrome::FindAnyBrowser(profile, false);
   if (browser && browser->window()) {
     OnBrowserWindowReady(browser);
   } else {
     registrar_.Add(this,
                    chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
   }
 }