Remove base::StringValue

components/user_manager/user_manager_base.cc

 // Copyright 2014 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 "components/user_manager/user_manager_base.h"
 
 #include <stddef.h>
 #include <set>
 #include <utility>
 
@@ skipping 283 matching lines @@
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   RemoveNonCryptohomeData(account_id);
   if (user_loading_stage_ == STAGE_LOADED) {
     DeleteUser(RemoveRegularOrSupervisedUserFromList(account_id));
   } else if (user_loading_stage_ == STAGE_LOADING) {
     DCHECK(IsSupervisedAccountId(account_id) ||
            HasPendingBootstrap(account_id));
     // Special case, removing partially-constructed supervised user or
     // boostrapping user during user list loading.
     ListPrefUpdate users_update(GetLocalState(), kRegularUsers);
-    users_update->Remove(base::StringValue(account_id.GetUserEmail()), nullptr);
+    users_update->Remove(base::Value(account_id.GetUserEmail()), nullptr);
     OnUserRemoved(account_id);
   } else {
     NOTREACHED() << "Users are not loaded yet.";
     return;
   }
 
   // Make sure that new data is persisted to Local State.
   GetLocalState()->CommitPendingWrite();
 }
 
@@ skipping 79 matching lines @@
 
   if (User* user = FindUserAndModify(account_id)) {
     user->set_display_name(display_name);
 
     // Do not update local state if data stored or cached outside the user's
     // cryptohome is to be treated as ephemeral.
     if (!IsUserNonCryptohomeDataEphemeral(account_id)) {
       DictionaryPrefUpdate display_name_update(GetLocalState(),
                                                kUserDisplayName);
       display_name_update->SetWithoutPathExpansion(
-          account_id.GetUserEmail(), new base::StringValue(display_name));
+          account_id.GetUserEmail(), new base::Value(display_name));
     }
   }
 }
 
 base::string16 UserManagerBase::GetUserDisplayName(
     const AccountId& account_id) const {
   const User* user = FindUser(account_id);
   return user ? user->display_name() : base::string16();
 }
 
 void UserManagerBase::SaveUserDisplayEmail(const AccountId& account_id,
                                            const std::string& display_email) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   User* user = FindUserAndModify(account_id);
   if (!user) {
     LOG(ERROR) << "User not found: " << account_id.GetUserEmail();
     return;  // Ignore if there is no such user.
   }
 
   user->set_display_email(display_email);
 
   // Do not update local state if data stored or cached outside the user's
   // cryptohome is to be treated as ephemeral.
   if (IsUserNonCryptohomeDataEphemeral(account_id))
     return;
 
   DictionaryPrefUpdate display_email_update(GetLocalState(), kUserDisplayEmail);
-  display_email_update->SetWithoutPathExpansion(
-      account_id.GetUserEmail(), new base::StringValue(display_email));
+  display_email_update->SetWithoutPathExpansion(account_id.GetUserEmail(),
+                                                new base::Value(display_email));
 }
 
 std::string UserManagerBase::GetUserDisplayEmail(
     const AccountId& account_id) const {
   const User* user = FindUser(account_id);
   return user ? user->display_email() : account_id.GetUserEmail();
 }
 
 void UserManagerBase::SaveUserType(const AccountId& account_id,
                                    const UserType& user_type) {
@@ skipping 21 matching lines @@
     const UserAccountData& account_data) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   SaveUserDisplayName(account_id, account_data.display_name());
 
   if (User* user = FindUserAndModify(account_id)) {
     base::string16 given_name = account_data.given_name();
     user->set_given_name(given_name);
     if (!IsUserNonCryptohomeDataEphemeral(account_id)) {
       DictionaryPrefUpdate given_name_update(GetLocalState(), kUserGivenName);
-      given_name_update->SetWithoutPathExpansion(
-          account_id.GetUserEmail(), new base::StringValue(given_name));
+      given_name_update->SetWithoutPathExpansion(account_id.GetUserEmail(),
+                                                 new base::Value(given_name));
     }
   }
 
   UpdateUserAccountLocale(account_id, account_data.locale());
 }
 
 void UserManagerBase::ParseUserList(const base::ListValue& users_list,
                                     const std::set<AccountId>& existing_users,
                                     std::vector<AccountId>* users_vector,
                                     std::set<AccountId>* users_set) {
@@ skipping 372 matching lines @@
 }
 
 void UserManagerBase::GuestUserLoggedIn() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   active_user_ = User::CreateGuestUser(GetGuestAccountId());
 }
 
 void UserManagerBase::AddUserRecord(User* user) {
   // Add the user to the front of the user list.
   ListPrefUpdate prefs_users_update(GetLocalState(), kRegularUsers);
-  prefs_users_update->Insert(0, base::MakeUnique<base::StringValue>(
-                                    user->GetAccountId().GetUserEmail()));
+  prefs_users_update->Insert(
+      0, base::MakeUnique<base::Value>(user->GetAccountId().GetUserEmail()));
   users_.insert(users_.begin(), user);
 }
 
 void UserManagerBase::RegularUserLoggedIn(const AccountId& account_id) {
   // Remove the user from the user list.
   active_user_ = RemoveRegularOrSupervisedUserFromList(account_id);
 
   // If the user was not found on the user list, create a new user.
   SetIsCurrentUserNew(!active_user_);
   if (IsCurrentUserNew()) {
@@ skipping 207 matching lines @@
 }
 
 void UserManagerBase::DeleteUser(User* user) {
   const bool is_active_user = (user == active_user_);
   delete user;
   if (is_active_user)
     active_user_ = nullptr;
 }
 
 }  // namespace user_manager