Remove base::FundamentalValue

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 343 matching lines @@
     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::FundamentalValue(auth_type), base::StringValue(auth_value));
+      base::StringValue(account_id.GetUserEmail()), base::Value(auth_type),
+      base::StringValue(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 17 matching lines @@
   NOTREACHED();
 }
 
 void UserManagerScreenHandler::HandleInitialize(const base::ListValue* args) {
   // If the URL has a hash parameter, store it for later.
   args->GetString(0, &url_hash_);
 
   SendUserList();
   web_ui()->CallJavascriptFunctionUnsafe(
       "cr.ui.UserManager.showUserManagerScreen",
-      base::FundamentalValue(IsGuestModeEnabled()),
-      base::FundamentalValue(IsAddPersonEnabled()));
+      base::Value(IsGuestModeEnabled()), base::Value(IsAddPersonEnabled()));
 
   proximity_auth::ScreenlockBridge::Get()->SetLockHandler(this);
 }
 
 void UserManagerScreenHandler::HandleAuthenticatedLaunchUser(
     const base::ListValue* args) {
   const base::Value* profile_path_value;
   if (!args->Get(0, &profile_path_value))
     return;
 
@@ skipping 115 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::FundamentalValue(
-          profiles::AreAllNonChildNonSupervisedProfilesLocked()));
+      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))
     return;
@@ skipping 130 matching lines @@
 
   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));
 
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "updateRemoveWarningDialogSetMessage", base::StringValue(profile_path),
-      message, base::FundamentalValue(total_count));
+  web_ui()->CallJavascriptFunctionUnsafe("updateRemoveWarningDialogSetMessage",
+                                         base::StringValue(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 263 matching lines @@
 
     // GetProfileByPath returns a pointer if the profile is fully loaded, NULL
     // otherwise.
     Profile* profile =
         g_browser_process->profile_manager()->GetProfileByPath(profile_path);
     profile_value->SetBoolean(kKeyIsProfileLoaded, profile != nullptr);
 
     users_list.Append(std::move(profile_value));
   }
 
-  web_ui()->CallJavascriptFunctionUnsafe(
-      "login.AccountPickerScreen.loadUsers", users_list,
-      base::FundamentalValue(IsGuestModeEnabled()));
+  web_ui()->CallJavascriptFunctionUnsafe("login.AccountPickerScreen.loadUsers",
+                                         users_list,
+                                         base::Value(IsGuestModeEnabled()));
 
   // This is the latest C++ code we have in the flow to show the UserManager.
   // This may be invoked more than once per UserManager lifetime; the
   // UserManager will ensure all relevant logging only happens once.
   UserManager::OnUserManagerShown();
 }
 
 void UserManagerScreenHandler::ReportAuthenticationResult(
     bool success,
     ProfileMetrics::ProfileAuth auth) {
   ProfileMetrics::LogProfileAuthResult(auth);
   email_address_.clear();
 
   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::FundamentalValue(0),
+        "cr.ui.UserManager.showSignInError", base::Value(0),
         base::StringValue(l10n_util::GetStringUTF8(
             auth == ProfileMetrics::AUTH_FAILED_OFFLINE
                 ? IDS_LOGIN_ERROR_AUTHENTICATING_OFFLINE
                 : IDS_LOGIN_ERROR_AUTHENTICATING)),
-        base::StringValue(""), base::FundamentalValue(0));
+        base::StringValue(""), 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());
   }
 }