Migrate base::Value::Append() calls in chrome/browser/ash

Value::Append() is deprecated, in favor of Value::List::Append(). Also
migrate some related Value::Set*Key() calls, for the similar reasons.

Bug: 1404827
Change-Id: I009ff4e666f7672eed52553a11746cd95d827d3a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4186293
Reviewed-by: Achuith Bhandarkar <achuith@chromium.org>
Commit-Queue: Matt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1095735}

chrome/browser/ash/app_mode/kiosk_crash_restore_browsertest.cc

@@ -97,9 +97,10 @@ class KioskCrashRestoreTest : public MixinBasedInProcessBrowserTest,
     g_browser_process->local_state()->SetString(prefs::kDeviceSettingsCache,
                                                 encoded);
 
-    base::Value accounts(base::Value::Type::LIST);
+    base::Value::List accounts;
     accounts.Append(GetTestAppUserId());
-    g_browser_process->local_state()->Set("PublicAccounts", accounts);
+    g_browser_process->local_state()->SetList("PublicAccounts",
+                                              std::move(accounts));
   }
 
   policy::DevicePolicyBuilder device_policy_;

chrome/browser/ash/crosapi/crosapi_util_unittest.cc

@@ -165,14 +165,14 @@ TEST_F(CrosapiUtilTest, DeviceSettingsWithData) {
       ->SetInteger(ash::kReportDeviceNetworkTelemetryCollectionRateMs,
                    kReportDeviceNetworkTelemetryCollectionRateMs);
 
-  base::Value allowlist(base::Value::Type::LIST);
-  base::Value ids(base::Value::Type::DICTIONARY);
-  ids.SetIntKey(ash::kUsbDetachableAllowlistKeyVid, 2);
-  ids.SetIntKey(ash::kUsbDetachableAllowlistKeyPid, 3);
+  base::Value::List allowlist;
+  base::Value::Dict ids;
+  ids.Set(ash::kUsbDetachableAllowlistKeyVid, 2);
+  ids.Set(ash::kUsbDetachableAllowlistKeyPid, 3);
   allowlist.Append(std::move(ids));
 
   testing_profile_.ScopedCrosSettingsTestHelper()->GetStubbedProvider()->Set(
-      ash::kUsbDetachableAllowlist, std::move(allowlist));
+      ash::kUsbDetachableAllowlist, base::Value(std::move(allowlist)));
 
   auto settings = browser_util::GetDeviceSettings();
   testing_profile_.ScopedCrosSettingsTestHelper()

chrome/browser/ash/file_manager/guest_os_file_tasks_unittest.cc

@@ -61,21 +61,21 @@ class GuestOsFileTasksTest : public testing::Test {
     ScopedDictPrefUpdate update(profile_.GetPrefs(),
                                 guest_os::prefs::kGuestOsRegistry);
     base::Value::Dict& registry = update.Get();
-    base::Value app(base::Value::Type::DICTIONARY);
-    app.SetKey("container_name", base::Value("penguin"));
-    base::Value mime_list(base::Value::Type::LIST);
+    base::Value::Dict app;
+    app.Set("container_name", "penguin");
+    base::Value::List mime_list;
     for (const auto& mime : mimes)
       mime_list.Append(mime);
-    app.SetKey("mime_types", std::move(mime_list));
-    base::Value extension_list(base::Value::Type::LIST);
+    app.Set("mime_types", std::move(mime_list));
+    base::Value::List extension_list;
     for (const auto& extension : extensions)
       extension_list.Append(extension);
-    app.SetKey("extensions", std::move(extension_list));
-    base::Value name_dict(base::Value::Type::DICTIONARY);
-    name_dict.SetKey("", base::Value(name));
-    app.SetKey("name", std::move(name_dict));
-    app.SetKey("vm_name", base::Value("termina"));
-    app.SetIntKey("vm_type", static_cast<int>(vm_type));
+    app.Set("extensions", std::move(extension_list));
+    base::Value::Dict name_dict;
+    name_dict.Set("", name);
+    app.Set("name", std::move(name_dict));
+    app.Set("vm_name", "termina");
+    app.Set("vm_type", static_cast<int>(vm_type));
     registry.Set(id, std::move(app));
   }
 

chrome/browser/ash/file_system_provider/registry.cc

@@ -51,42 +51,38 @@ Registry::~Registry() {
 void Registry::RememberFileSystem(
     const ProvidedFileSystemInfo& file_system_info,
     const Watchers& watchers) {
-  base::Value file_system(base::Value::Type::DICTIONARY);
-  file_system.SetKey(kPrefKeyFileSystemId,
-                     base::Value(file_system_info.file_system_id()));
-  file_system.SetKey(kPrefKeyDisplayName,
-                     base::Value(file_system_info.display_name()));
-  file_system.SetKey(kPrefKeyWritable,
-                     base::Value(file_system_info.writable()));
-  file_system.SetKey(kPrefKeySupportsNotifyTag,
-                     base::Value(file_system_info.supports_notify_tag()));
-  file_system.SetKey(kPrefKeyOpenedFilesLimit,
-                     base::Value(file_system_info.opened_files_limit()));
+  base::Value::Dict file_system;
+  file_system.Set(kPrefKeyFileSystemId, file_system_info.file_system_id());
+  file_system.Set(kPrefKeyDisplayName, file_system_info.display_name());
+  file_system.Set(kPrefKeyWritable, file_system_info.writable());
+  file_system.Set(kPrefKeySupportsNotifyTag,
+                  file_system_info.supports_notify_tag());
+  file_system.Set(kPrefKeyOpenedFilesLimit,
+                  file_system_info.opened_files_limit());
   // We don't need to write and read "persistent" field (in MountOptions) to
   // and from preference because all filesystems which are remembered must be
   // persistent.
 
-  base::Value watchers_value(base::Value::Type::DICTIONARY);
+  base::Value::Dict watchers_dict;
 
   for (const auto& it : watchers) {
-    base::Value watcher(base::Value::Type::DICTIONARY);
-    watcher.SetKey(kPrefKeyWatcherEntryPath,
-                   base::Value(it.second.entry_path.value()));
-    watcher.SetKey(kPrefKeyWatcherRecursive, base::Value(it.second.recursive));
-    watcher.SetKey(kPrefKeyWatcherLastTag, base::Value(it.second.last_tag));
-    base::Value persistent_origins_value(base::Value::Type::LIST);
+    base::Value::Dict watcher;
+    watcher.Set(kPrefKeyWatcherEntryPath, it.second.entry_path.value());
+    watcher.Set(kPrefKeyWatcherRecursive, it.second.recursive);
+    watcher.Set(kPrefKeyWatcherLastTag, it.second.last_tag);
+    base::Value::List persistent_origins_value;
     for (const auto& subscriber_it : it.second.subscribers) {
       // Only persistent subscribers should be stored in persistent storage.
       // Other ones should not be restired after a restart.
       if (subscriber_it.second.persistent) {
         persistent_origins_value.Append(subscriber_it.first.spec());
       }
     }
-    watcher.SetKey(kPrefKeyWatcherPersistentOrigins,
-                   std::move(persistent_origins_value));
-    watchers_value.SetKey(it.second.entry_path.value(), std::move(watcher));
+    watcher.Set(kPrefKeyWatcherPersistentOrigins,
+                std::move(persistent_origins_value));
+    watchers_dict.Set(it.second.entry_path.value(), std::move(watcher));
   }
-  file_system.SetKey(kPrefKeyWatchers, std::move(watchers_value));
+  file_system.Set(kPrefKeyWatchers, std::move(watchers_dict));
 
   PrefService* const pref_service = profile_->GetPrefs();
   DCHECK(pref_service);

chrome/browser/ash/file_system_provider/registry_unittest.cc

@@ -58,37 +58,35 @@ void RememberFakeFileSystem(TestingProfile* profile,
       profile->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
-  base::Value extensions{base::Value::Type::DICTIONARY};
-  base::Value file_system{base::Value::Type::DICTIONARY};
-  file_system.SetKey(kPrefKeyFileSystemId, base::Value(kFileSystemId));
-  file_system.SetKey(kPrefKeyDisplayName, base::Value(kDisplayName));
-  file_system.SetKey(kPrefKeyWritable, base::Value(writable));
-  file_system.SetKey(kPrefKeySupportsNotifyTag,
-                     base::Value(supports_notify_tag));
-  file_system.SetKey(kPrefKeyOpenedFilesLimit, base::Value(opened_files_limit));
+  base::Value::Dict extensions;
+  base::Value::Dict file_system;
+  file_system.Set(kPrefKeyFileSystemId, kFileSystemId);
+  file_system.Set(kPrefKeyDisplayName, kDisplayName);
+  file_system.Set(kPrefKeyWritable, writable);
+  file_system.Set(kPrefKeySupportsNotifyTag, supports_notify_tag);
+  file_system.Set(kPrefKeyOpenedFilesLimit, opened_files_limit);
 
   // Remember watchers.
-  base::Value watcher_value{base::Value::Type::DICTIONARY};
-  watcher_value.SetKey(kPrefKeyWatcherEntryPath,
-                       base::Value(watcher.entry_path.value()));
-  watcher_value.SetKey(kPrefKeyWatcherRecursive,
-                       base::Value(watcher.recursive));
-  watcher_value.SetKey(kPrefKeyWatcherLastTag, base::Value(watcher.last_tag));
-  base::Value persistent_origins_value{base::Value::Type::LIST};
+  base::Value::Dict watcher_value;
+  watcher_value.Set(kPrefKeyWatcherEntryPath, watcher.entry_path.value());
+  watcher_value.Set(kPrefKeyWatcherRecursive, watcher.recursive);
+  watcher_value.Set(kPrefKeyWatcherLastTag, watcher.last_tag);
+  base::Value::List persistent_origins_value;
   for (const auto& subscriber_it : watcher.subscribers) {
     if (subscriber_it.second.persistent)
       persistent_origins_value.Append(subscriber_it.first.spec());
   }
 
-  watcher_value.SetKey(kPrefKeyWatcherPersistentOrigins,
-                       std::move(persistent_origins_value));
-  base::Value watchers{base::Value::Type::DICTIONARY};
-  watchers.SetKey(watcher.entry_path.value(), std::move(watcher_value));
-  file_system.SetKey(kPrefKeyWatchers, std::move(watchers));
-  base::Value file_systems{base::Value::Type::DICTIONARY};
-  file_systems.SetKey(kFileSystemId, std::move(file_system));
-  extensions.SetKey(kProviderId.ToString(), std::move(file_systems));
-  pref_service->Set(prefs::kFileSystemProviderMounted, std::move(extensions));
+  watcher_value.Set(kPrefKeyWatcherPersistentOrigins,
+                    std::move(persistent_origins_value));
+  base::Value::Dict watchers;
+  watchers.Set(watcher.entry_path.value(), std::move(watcher_value));
+  file_system.Set(kPrefKeyWatchers, std::move(watchers));
+  base::Value::Dict file_systems;
+  file_systems.Set(kFileSystemId, std::move(file_system));
+  extensions.Set(kProviderId.ToString(), std::move(file_systems));
+  pref_service->SetDict(prefs::kFileSystemProviderMounted,
+                        std::move(extensions));
 }
 
 }  // namespace
@@ -208,12 +206,12 @@ TEST_F(FileSystemProviderRegistryTest, RememberFileSystem) {
   EXPECT_TRUE(opened_files_limit.has_value());
   EXPECT_EQ(kOpenedFilesLimit, opened_files_limit.value());
 
-  const base::Value::Dict* watchers_value =
+  const base::Value::Dict* watchers_dict =
       file_system->FindDict(kPrefKeyWatchers);
-  ASSERT_TRUE(watchers_value);
+  ASSERT_TRUE(watchers_dict);
 
   const base::Value::Dict* watcher =
-      watchers_value->FindDict(fake_watcher_.entry_path.value());
+      watchers_dict->FindDict(fake_watcher_.entry_path.value());
   ASSERT_TRUE(watcher);
 
   const std::string* entry_path = watcher->FindString(kPrefKeyWatcherEntryPath);
@@ -296,12 +294,12 @@ TEST_F(FileSystemProviderRegistryTest, UpdateWatcherTag) {
   const base::Value::Dict* file_system = file_systems->FindDict(kFileSystemId);
   ASSERT_TRUE(file_system);
 
-  const base::Value::Dict* watchers_value =
+  const base::Value::Dict* watchers_dict =
       file_system->FindDict(kPrefKeyWatchers);
-  ASSERT_TRUE(watchers_value);
+  ASSERT_TRUE(watchers_dict);
 
   const base::Value::Dict* watcher =
-      watchers_value->FindDict(fake_watcher_.entry_path.value());
+      watchers_dict->FindDict(fake_watcher_.entry_path.value());
   ASSERT_TRUE(watcher);
 
   const std::string* last_tag = watcher->FindString(kPrefKeyWatcherLastTag);

chrome/browser/ash/login/saml/security_token_saml_test.cc

@@ -184,14 +184,17 @@ void SecurityTokenSamlTest::SetClientCertAutoSelectPolicy() {
       policy_map.GetMutable(policy::key::kAutoSelectCertificateForUrls);
   if (existing_entry) {
     // Append to the existing policy.
-    existing_entry->value(base::Value::Type::LIST)->Append(policy_item_value);
+    existing_entry->value(base::Value::Type::LIST)
+        ->GetList()
+        .Append(policy_item_value);
   } else {
     // Set the new policy value.
-    base::Value policy_value(base::Value::Type::LIST);
+    base::Value::List policy_value;
     policy_value.Append(policy_item_value);
     policy_map.Set(policy::key::kAutoSelectCertificateForUrls,
                    policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_MACHINE,
-                   policy::POLICY_SOURCE_CLOUD, std::move(policy_value),
+                   policy::POLICY_SOURCE_CLOUD,
+                   base::Value(std::move(policy_value)),
                    /*external_data_fetcher=*/nullptr);
   }
   policy_provider_.UpdateChromePolicy(policy_map);

chrome/browser/ash/login/screens/app_downloading_screen_browsertest.cc

@@ -113,10 +113,10 @@ IN_PROC_BROWSER_TEST_F(AppDownloadingScreenTest, SingleAppSelected) {
       ->defer_oobe_flow_finished_for_tests = true;
 
   Login();
-  base::Value apps(base::Value::Type::LIST);
+  base::Value::List apps;
   apps.Append("app.test.package.1");
 
-  ProfileManager::GetActiveUserProfile()->GetPrefs()->Set(
+  ProfileManager::GetActiveUserProfile()->GetPrefs()->SetList(
       arc::prefs::kArcFastAppReinstallPackages, std::move(apps));
   ShowAppDownloadingScreen();
 
@@ -136,11 +136,11 @@ IN_PROC_BROWSER_TEST_F(AppDownloadingScreenTest, MultipleAppsSelected) {
       ->defer_oobe_flow_finished_for_tests = true;
 
   Login();
-  base::Value apps(base::Value::Type::LIST);
+  base::Value::List apps;
   apps.Append("app.test.package.1");
   apps.Append("app.test.package.2");
 
-  ProfileManager::GetActiveUserProfile()->GetPrefs()->Set(
+  ProfileManager::GetActiveUserProfile()->GetPrefs()->SetList(
       arc::prefs::kArcFastAppReinstallPackages, std::move(apps));
 
   ShowAppDownloadingScreen();

chrome/browser/ash/login/screens/recommend_apps/fake_recommend_apps_fetcher.cc

@@ -26,16 +26,16 @@ FakeRecommendAppsFetcher::FakeRecommendAppsFetcher(
 FakeRecommendAppsFetcher::~FakeRecommendAppsFetcher() = default;
 
 void FakeRecommendAppsFetcher::OnTimer() {
-  base::Value apps(base::Value::Type::LIST);
+  base::Value::List apps;
   for (int i = 0; i < base::clamp(fake_apps_count_, 0, kMaxAppCount); i++) {
-    base::Value app(base::Value::Type::DICTIONARY);
-    app.SetKey("name", base::Value(base::StringPrintf("Fake App %d", (i + 1))));
-    app.SetKey("package_name", base::Value(base::StringPrintf(
-                                   "com.example.fake.app%d", (i + 1))));
+    base::Value::Dict app;
+    app.Set("name", base::StringPrintf("Fake App %d", (i + 1)));
+    app.Set("package_name",
+            base::StringPrintf("com.example.fake.app%d", (i + 1)));
     apps.Append(std::move(app));
   }
 
-  delegate_->OnLoadSuccess(std::move(apps));
+  delegate_->OnLoadSuccess(base::Value(std::move(apps)));
 }
 
 void FakeRecommendAppsFetcher::Start() {

chrome/browser/ash/login/test/session_flags_manager.cc

@@ -232,15 +232,15 @@ base::Value SessionFlagsManager::GetSwitchesValueFromArgv(
   base::CommandLine cmd_line(base::CommandLine::NO_PROGRAM);
   cmd_line.InitFromArgv(argv);
 
-  base::Value flag_list(base::Value::Type::LIST);
+  base::Value::List flag_list;
   for (const auto& flag : cmd_line.GetSwitches()) {
-    base::Value flag_value(base::Value::Type::DICTIONARY);
-    flag_value.SetKey(kFlagNameKey, base::Value(flag.first));
-    flag_value.SetKey(kFlagValueKey, base::Value(flag.second));
+    base::Value::Dict flag_value;
+    flag_value.Set(kFlagNameKey, flag.first);
+    flag_value.Set(kFlagValueKey, flag.second);
 
     flag_list.Append(std::move(flag_value));
   }
-  return flag_list;
+  return base::Value(std::move(flag_list));
 }
 
 }  // namespace test

chrome/browser/ash/net/rollback_network_config/rollback_network_config.cc

@@ -298,13 +298,13 @@ void RollbackNetworkConfig::Exporter::SendNetworkConfigs(
 }
 
 std::string RollbackNetworkConfig::Exporter::SerializeNetworkConfigs() const {
-  base::Value network_config_list(base::Value::Type::LIST);
+  base::Value::List network_config_list;
   for (const auto& network_config : network_configs_) {
     network_config_list.Append(network_config.Clone());
   }
 
-  base::Value complete_network_configuration(base::Value::Type::DICTIONARY);
-  complete_network_configuration.SetKey(
+  base::Value::Dict complete_network_configuration;
+  complete_network_configuration.Set(
       onc::toplevel_config::kNetworkConfigurations,
       std::move(network_config_list));
   std::string serialized_config;

chrome/browser/ash/ownership/owner_settings_service_ash.cc

@@ -325,15 +325,16 @@ bool OwnerSettingsServiceAsh::Set(const std::string& setting,
 bool OwnerSettingsServiceAsh::AppendToList(const std::string& setting,
                                            const base::Value& value) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  const base::Value* old_value = CrosSettings::Get()->GetPref(setting);
-  if (old_value && !old_value->is_list())
+  const base::Value::List* old_value;
+  if (!CrosSettings::Get()->GetList(setting, &old_value)) {
     return false;
+  }
 
-  base::Value new_value =
-      old_value ? old_value->Clone() : base::Value(base::Value::Type::LIST);
+  base::Value::List new_value =
+      old_value ? old_value->Clone() : base::Value::List();
 
   new_value.Append(value.Clone());
-  return Set(setting, new_value);
+  return Set(setting, base::Value(std::move(new_value)));
 }
 
 bool OwnerSettingsServiceAsh::RemoveFromList(const std::string& setting,