[CodeHealth] Replace Value::SetKey() calls -> Dict::Set() in misc files

Bug: 1439196
Change-Id: I5f88e69e88eae322da0eb44cce61a54a4256802d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4533496
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Daniel Cheng <dcheng@chromium.org>
Owners-Override: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1144519}

ash/keyboard/keyboard_controller_impl_unittest.cc

@@ -185,15 +185,16 @@ class KeyboardControllerImplTest : public AshTestBase {
   }
 
   void SetKeyboardConfigToPref(const base::Value& value) {
-    base::Value features(base::Value::Type::DICT);
-    features.SetKey("auto_complete_enabled", value.Clone());
-    features.SetKey("auto_correct_enabled", value.Clone());
-    features.SetKey("handwriting_enabled", value.Clone());
-    features.SetKey("spell_check_enabled", value.Clone());
-    features.SetKey("voice_input_enabled", value.Clone());
+    auto features = base::Value::Dict()
+                        .Set("auto_complete_enabled", value.Clone())
+                        .Set("auto_correct_enabled", value.Clone())
+                        .Set("handwriting_enabled", value.Clone())
+                        .Set("spell_check_enabled", value.Clone())
+                        .Set("voice_input_enabled", value.Clone());
     PrefService* prefs =
         Shell::Get()->session_controller()->GetLastActiveUserPrefService();
-    prefs->Set(prefs::kAccessibilityVirtualKeyboardFeatures, features);
+    prefs->SetDict(prefs::kAccessibilityVirtualKeyboardFeatures,
+                   std::move(features));
   }
 
   void VerifyKeyboardConfig(const KeyboardConfig& config, bool expected_value) {

base/json/json_reader.cc

@@ -52,31 +52,30 @@ void ListAppendValue(ContextPointer& ctx, T v) {
 ContextPointer& DictSetList(ContextPointer& ctx,
                             rust::Str key,
                             size_t reserve) {
-  auto& value = reinterpret_cast<base::Value&>(ctx);
+  auto& dict = reinterpret_cast<base::Value&>(ctx).GetDict();
   base::Value::List list;
   list.reserve(reserve);
-  value.SetKey(base::RustStrToStringPiece(key), base::Value(std::move(list)));
+  dict.Set(base::RustStrToStringPiece(key), std::move(list));
   return reinterpret_cast<ContextPointer&>(
-      *value.GetDict().Find(base::RustStrToStringPiece(key)));
+      *dict.Find(base::RustStrToStringPiece(key)));
 }
 
 ContextPointer& DictSetDict(ContextPointer& ctx, rust::Str key) {
-  auto& value = reinterpret_cast<base::Value&>(ctx);
-  value.SetKey(base::RustStrToStringPiece(key),
-               base::Value(base::Value::Dict()));
+  auto& dict = reinterpret_cast<base::Value&>(ctx).GetDict();
+  dict.Set(base::RustStrToStringPiece(key), base::Value(base::Value::Dict()));
   return reinterpret_cast<ContextPointer&>(
-      *value.GetDict().Find(base::RustStrToStringPiece(key)));
+      *dict.Find(base::RustStrToStringPiece(key)));
 }
 
 void DictSetNone(ContextPointer& ctx, rust::Str key) {
-  auto& value = reinterpret_cast<base::Value&>(ctx);
-  value.SetKey(base::RustStrToStringPiece(key), base::Value());
+  auto& dict = reinterpret_cast<base::Value&>(ctx).GetDict();
+  dict.Set(base::RustStrToStringPiece(key), base::Value());
 }
 
 template <class T, class As = T>
 void DictSetValue(ContextPointer& ctx, rust::Str key, T v) {
-  auto& value = reinterpret_cast<base::Value&>(ctx);
-  value.SetKey(base::RustStrToStringPiece(key), base::Value(As{v}));
+  auto& dict = reinterpret_cast<base::Value&>(ctx).GetDict();
+  dict.Set(base::RustStrToStringPiece(key), base::Value(As{v}));
 }
 
 JSONReader::Result DecodeJSONInRust(const base::StringPiece& json,

chrome/browser/media/cdm_document_service_impl_test.cc

@@ -111,9 +111,9 @@ class CdmDocumentServiceImplTest : public ChromeRenderViewHostTestHarness {
 
     // Create (or overwrite) an entry with only an origin id to simulate some
     // kind of corruption or simply an update to the preference format.
-    base::Value entry(base::Value::Type::DICT);
-    entry.SetKey(kOriginId, base::UnguessableTokenToValue(
-                                base::UnguessableToken::Create()));
+    auto entry = base::Value::Dict().Set(
+        kOriginId,
+        base::UnguessableTokenToValue(base::UnguessableToken::Create()));
 
     ScopedDictPrefUpdate update(user_prefs, prefs::kMediaCdmOriginData);
     base::Value::Dict& dict = update.Get();

chrome/browser/policy/messaging_layer/upload/upload_client_unittest.cc

@@ -120,8 +120,8 @@ TEST_P(UploadClientTest, CreateUploadClientAndUploadRecords) {
   static constexpr int64_t kExpectedCallTimes = 10;
   static constexpr int64_t kGenerationId = 1234;
 
-  base::Value data{base::Value::Type::DICT};
-  data.SetKey("TEST_KEY", base::Value("TEST_VALUE"));
+  base::Value::Dict data;
+  data.Set("TEST_KEY", "TEST_VALUE");
 
   std::string json_data;
   ASSERT_TRUE(base::JSONWriter::Write(data, &json_data));

chrome/browser/profiles/profile_attributes_entry.cc

@@ -569,14 +569,13 @@ base::flat_set<std::string> ProfileAttributesEntry::GetGaiaIds() const {
 
 void ProfileAttributesEntry::SetGaiaIds(
     const base::flat_set<std::string>& gaia_ids) {
-  base::Value accounts(base::Value::Type::DICT);
+  base::Value::Dict accounts;
   for (const auto& gaia_id : gaia_ids) {
-    base::Value dict(base::Value::Type::DICT);
     // The dictionary is empty for now, but can hold account-specific info in
     // the future.
-    accounts.SetKey(gaia_id, std::move(dict));
+    accounts.Set(gaia_id, base::Value::Dict());
   }
-  SetValue(kAllAccountsKey, std::move(accounts));
+  SetValue(kAllAccountsKey, base::Value(std::move(accounts)));
 }
 
 void ProfileAttributesEntry::SetLocalProfileName(const std::u16string& name,

chromecast/base/device_capabilities_impl_unittest.cc

@@ -183,10 +183,7 @@ base::Value GetSampleDynamicCapabilityNewValue() {
 bool JsonStringEquals(const std::string& json,
                       const std::string& key,
                       const base::Value& value) {
-  base::Value dict_value(base::Value::Type::DICT);
-  dict_value.SetKey(key, value.Clone());
-  std::string dict_json;
-  return base::JSONWriter::Write(dict_value, &dict_json) && dict_json == json;
+  return base::WriteJson(base::Value::Dict().Set(key, value.Clone())) == json;
 }
 
 // The function runs through the set of basic operations of DeviceCapabilities.

components/privacy_sandbox/privacy_sandbox_settings_impl.cc

@@ -58,14 +58,12 @@ std::vector<ContentSettingsPattern> FledgeBlockToContentSettingsPatterns(
           ContentSettingsPattern::FromString(entry)};
 }
 
-// Returns a base::Value for storage in prefs that represents |topic| blocked
-// at the current time.
-base::Value CreateBlockedTopicEntry(const CanonicalTopic& topic) {
-  base::Value entry(base::Value::Type::DICT);
-  entry.SetKey(kBlockedTopicsTopicKey, topic.ToValue());
-  entry.SetKey(kBlockedTopicsBlockTimeKey,
-               base::TimeToValue(base::Time::Now()));
-  return entry;
+// Returns a base::Value::Dict for storage in prefs that represents |topic|
+// blocked at the current time.
+base::Value::Dict CreateBlockedTopicEntry(const CanonicalTopic& topic) {
+  return base::Value::Dict()
+      .Set(kBlockedTopicsTopicKey, topic.ToValue())
+      .Set(kBlockedTopicsBlockTimeKey, base::TimeToValue(base::Time::Now()));
 }
 
 }  // namespace

remoting/test/it2me_cli_host.cc

@@ -146,9 +146,9 @@ void It2MeCliHost::CloseChannel(const std::string& error_message) {
 }
 
 void It2MeCliHost::SendMessageToHost(const std::string& type,
-                                     base::Value params) {
+                                     base::Value::Dict params) {
   std::string message_json;
-  params.SetKey(kMessageType, base::Value(type));
+  params.Set(kMessageType, type);
   base::JSONWriter::Write(params, &message_json);
   base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
       FROM_HERE, base::BindOnce(&It2MeCliHost::DoSendMessage,
@@ -175,14 +175,11 @@ void It2MeCliHost::StartCRDHostAndGetCode(OAuthTokenGetter::Status status,
   DCHECK(!host_);
 
   // Store all parameters for future connect call.
-  base::Value connect_params(base::Value::Type::DICT);
-
-  connect_params.SetKey(kUserName, base::Value(user_email));
-  connect_params.SetKey(kAuthServiceWithToken,
-                        base::Value("oauth2:" + access_token));
-  connect_params.SetKey(kSuppressUserDialogs, base::Value(true));
-  connect_params.SetKey(kSuppressNotifications, base::Value(true));
-  connect_params_ = std::move(connect_params);
+  connect_params_ = base::Value::Dict()
+                        .Set(kUserName, user_email)
+                        .Set(kAuthServiceWithToken, "oauth2:" + access_token)
+                        .Set(kSuppressUserDialogs, true)
+                        .Set(kSuppressNotifications, true);
 
   remote_connected_ = false;
   command_awaiting_crd_access_code_ = true;
@@ -190,8 +187,7 @@ void It2MeCliHost::StartCRDHostAndGetCode(OAuthTokenGetter::Status status,
   host_ = CreateNativeMessagingHost(ui_task_runner_);
   host_->Start(this);
 
-  base::Value params(base::Value::Type::DICT);
-  SendMessageToHost(kHelloMessage, std::move(params));
+  SendMessageToHost(kHelloMessage, base::Value::Dict());
 }
 
 void It2MeCliHost::ShutdownHost() {
@@ -261,8 +257,7 @@ void It2MeCliHost::OnStateRemoteDisconnected() {
   remote_connected_ = false;
   // Remote has disconnected, time to send "disconnect" that would result
   // in shutting down the host.
-  base::Value params(base::Value::Type::DICT);
-  SendMessageToHost(kDisconnectMessage, std::move(params));
+  SendMessageToHost(kDisconnectMessage, base::Value::Dict());
 }
 
 void It2MeCliHost::OnStateReceivedAccessCode(const base::Value::Dict& message) {
@@ -272,8 +267,7 @@ void It2MeCliHost::OnStateReceivedAccessCode(const base::Value::Dict& message) {
       // this CRD session through a remote command, and we can not send a new
       // access code. Assuming that the old access code is no longer valid, we
       // can only terminate the current CRD session.
-      base::Value params(base::Value::Type::DICT);
-      SendMessageToHost(kDisconnectMessage, std::move(params));
+      SendMessageToHost(kDisconnectMessage, base::Value::Dict());
     }
     return;
   }

remoting/test/it2me_cli_host.h

@@ -44,7 +44,7 @@ class It2MeCliHost final : public extensions::NativeMessageHost::Client {
   void CloseChannel(const std::string& error_message) override;
 
   // Sends message to host in separate task.
-  void SendMessageToHost(const std::string& type, base::Value params);
+  void SendMessageToHost(const std::string& type, base::Value::Dict params);
   // Actually sends message to host.
   void DoSendMessage(const std::string& json);
   void OnProtocolBroken(const std::string& message);
@@ -74,7 +74,7 @@ class It2MeCliHost final : public extensions::NativeMessageHost::Client {
   std::unique_ptr<extensions::NativeMessageHost> host_;
 
   // Filled structure with parameters for "connect" message.
-  base::Value connect_params_;
+  base::Value::Dict connect_params_;
 
   // Determines actions when receiving messages from CRD host,
   // if command is still running (no error / access code), then

services/network/test/trust_token_test_util.cc

@@ -5,7 +5,7 @@
 #include "services/network/test/trust_token_test_util.h"
 
 #include "base/json/json_reader.h"
-#include "base/json/json_string_value_serializer.h"
+#include "base/json/json_writer.h"
 #include "base/test/bind.h"
 #include "base/test/task_environment.h"
 #include "base/test/test_future.h"
@@ -161,33 +161,20 @@ SerializeTrustTokenParametersAndConstructExpectation(
     parameters.Set("issuers", std::move(issuers));
   }
 
-  std::string serialized_parameters;
-  JSONStringValueSerializer serializer(&serialized_parameters);
-  CHECK(serializer.Serialize(parameters));
-
-  return {std::move(trust_token_params), std::move(serialized_parameters)};
+  return {std::move(trust_token_params), *base::WriteJson(parameters)};
 }
 
 std::string WrapKeyCommitmentsForIssuers(
     base::flat_map<url::Origin, base::StringPiece> issuers_and_commitments) {
-  std::string ret;
-  JSONStringValueSerializer serializer(&ret);
-
-  base::Value to_serialize(base::Value::Type::DICT);
-
-  for (const auto& kv : issuers_and_commitments) {
-    const url::Origin& issuer = kv.first;
-    base::StringPiece commitment = kv.second;
-
+  base::Value::Dict to_serialize;
+  for (const auto& [issuer, commitment] : issuers_and_commitments) {
     // guard against accidentally passing an origin without a unique
     // serialization
     CHECK_NE(issuer.Serialize(), "null");
 
-    to_serialize.SetKey(issuer.Serialize(),
-                        *base::JSONReader::Read(commitment));
+    to_serialize.Set(issuer.Serialize(), *base::JSONReader::Read(commitment));
   }
-  CHECK(serializer.Serialize(to_serialize));
-  return ret;
+  return *base::WriteJson(to_serialize);
 }
 
 }  // namespace network