chore: modernize Value usage in converters (#34794)

* chore: modernize Value usage in converters

* Date is parsed as an empty object now

filenames.gni

@@ -643,8 +643,6 @@ filenames = {
     "shell/common/process_util.h",
     "shell/common/skia_util.cc",
     "shell/common/skia_util.h",
-    "shell/common/v8_value_converter.cc",
-    "shell/common/v8_value_converter.h",
     "shell/common/v8_value_serializer.cc",
     "shell/common/v8_value_serializer.h",
     "shell/common/world_ids.h",

shell/browser/api/electron_api_base_window.cc

@@ -288,7 +288,7 @@ void BaseWindow::OnExecuteAppCommand(const std::string& command_name) {
 }
 
 void BaseWindow::OnTouchBarItemResult(const std::string& item_id,
-                                      const base::DictionaryValue& details) {
+                                      const base::Value::Dict& details) {
   Emit("-touch-bar-interaction", item_id, details);
 }
 

shell/browser/api/electron_api_base_window.h

@@ -80,7 +80,7 @@ class BaseWindow : public gin_helper::TrackableObject<BaseWindow>,
   void OnWindowAlwaysOnTopChanged() override;
   void OnExecuteAppCommand(const std::string& command_name) override;
   void OnTouchBarItemResult(const std::string& item_id,
-                            const base::DictionaryValue& details) override;
+                            const base::Value::Dict& details) override;
   void OnNewWindowForTab() override;
   void OnSystemContextMenu(int x, int y, bool* prevent_default) override;
 #if BUILDFLAG(IS_WIN)

shell/browser/api/electron_api_content_tracing.cc

@@ -42,9 +42,10 @@ struct Converter<base::trace_event::TraceConfig> {
       }
     }
 
-    base::DictionaryValue memory_dump_config;
+    base::Value::Dict memory_dump_config;
     if (ConvertFromV8(isolate, val, &memory_dump_config)) {
-      *out = base::trace_event::TraceConfig(memory_dump_config);
+      *out = base::trace_event::TraceConfig(
+          base::Value(std::move(memory_dump_config)));
       return true;
     }
 

shell/browser/api/electron_api_cookies.cc

@@ -117,27 +117,27 @@ bool MatchesDomain(std::string filter, const std::string& domain) {
 }
 
 // Returns whether |cookie| matches |filter|.
-bool MatchesCookie(const base::Value& filter,
+bool MatchesCookie(const base::Value::Dict& filter,
                    const net::CanonicalCookie& cookie) {
   const std::string* str;
-  if ((str = filter.FindStringKey("name")) && *str != cookie.Name())
+  if ((str = filter.FindString("name")) && *str != cookie.Name())
     return false;
-  if ((str = filter.FindStringKey("path")) && *str != cookie.Path())
+  if ((str = filter.FindString("path")) && *str != cookie.Path())
     return false;
-  if ((str = filter.FindStringKey("domain")) &&
+  if ((str = filter.FindString("domain")) &&
       !MatchesDomain(*str, cookie.Domain()))
     return false;
-  absl::optional<bool> secure_filter = filter.FindBoolKey("secure");
+  absl::optional<bool> secure_filter = filter.FindBool("secure");
   if (secure_filter && *secure_filter == cookie.IsSecure())
     return false;
-  absl::optional<bool> session_filter = filter.FindBoolKey("session");
+  absl::optional<bool> session_filter = filter.FindBool("session");
   if (session_filter && *session_filter != !cookie.IsPersistent())
     return false;
   return true;
 }
 
 // Remove cookies from |list| not matching |filter|, and pass it to |callback|.
-void FilterCookies(const base::Value& filter,
+void FilterCookies(base::Value::Dict filter,
                    gin_helper::Promise<net::CookieList> promise,
                    const net::CookieList& cookies) {
   net::CookieList result;
@@ -149,11 +149,11 @@ void FilterCookies(const base::Value& filter,
 }
 
 void FilterCookieWithStatuses(
-    const base::Value& filter,
+    base::Value::Dict filter,
     gin_helper::Promise<net::CookieList> promise,
     const net::CookieAccessResultList& list,
     const net::CookieAccessResultList& excluded_list) {
-  FilterCookies(filter, std::move(promise),
+  FilterCookies(std::move(filter), std::move(promise),
                 net::cookie_util::StripAccessResults(list));
 }
 
@@ -231,7 +231,7 @@ v8::Local<v8::Promise> Cookies::Get(v8::Isolate* isolate,
   auto* storage_partition = browser_context_->GetDefaultStoragePartition();
   auto* manager = storage_partition->GetCookieManagerForBrowserProcess();
 
-  base::DictionaryValue dict;
+  base::Value::Dict dict;
   gin::ConvertFromV8(isolate, filter.GetHandle(), &dict);
 
   std::string url;
@@ -280,31 +280,31 @@ v8::Local<v8::Promise> Cookies::Remove(v8::Isolate* isolate,
 }
 
 v8::Local<v8::Promise> Cookies::Set(v8::Isolate* isolate,
-                                    const base::DictionaryValue& details) {
+                                    base::Value::Dict details) {
   gin_helper::Promise<void> promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
-  const std::string* url_string = details.FindStringKey("url");
+  const std::string* url_string = details.FindString("url");
   if (!url_string) {
     promise.RejectWithErrorMessage("Missing required option 'url'");
     return handle;
   }
-  const std::string* name = details.FindStringKey("name");
-  const std::string* value = details.FindStringKey("value");
-  const std::string* domain = details.FindStringKey("domain");
-  const std::string* path = details.FindStringKey("path");
-  bool http_only = details.FindBoolKey("httpOnly").value_or(false);
-  const std::string* same_site_string = details.FindStringKey("sameSite");
+  const std::string* name = details.FindString("name");
+  const std::string* value = details.FindString("value");
+  const std::string* domain = details.FindString("domain");
+  const std::string* path = details.FindString("path");
+  bool http_only = details.FindBool("httpOnly").value_or(false);
+  const std::string* same_site_string = details.FindString("sameSite");
   net::CookieSameSite same_site;
   std::string error = StringToCookieSameSite(same_site_string, &same_site);
   if (!error.empty()) {
     promise.RejectWithErrorMessage(error);
     return handle;
   }
-  bool secure = details.FindBoolKey("secure").value_or(
+  bool secure = details.FindBool("secure").value_or(
       same_site == net::CookieSameSite::NO_RESTRICTION);
   bool same_party =
-      details.FindBoolKey("sameParty")
+      details.FindBool("sameParty")
           .value_or(secure && same_site != net::CookieSameSite::STRICT_MODE);
 
   GURL url(url_string ? *url_string : "");
@@ -317,10 +317,9 @@ v8::Local<v8::Promise> Cookies::Set(v8::Isolate* isolate,
 
   auto canonical_cookie = net::CanonicalCookie::CreateSanitizedCookie(
       url, name ? *name : "", value ? *value : "", domain ? *domain : "",
-      path ? *path : "",
-      ParseTimeProperty(details.FindDoubleKey("creationDate")),
-      ParseTimeProperty(details.FindDoubleKey("expirationDate")),
-      ParseTimeProperty(details.FindDoubleKey("lastAccessDate")), secure,
+      path ? *path : "", ParseTimeProperty(details.FindDouble("creationDate")),
+      ParseTimeProperty(details.FindDouble("expirationDate")),
+      ParseTimeProperty(details.FindDouble("lastAccessDate")), secure,
       http_only, same_site, net::COOKIE_PRIORITY_DEFAULT, same_party,
       absl::nullopt);
   if (!canonical_cookie || !canonical_cookie->IsCanonical()) {

shell/browser/api/electron_api_cookies.h

@@ -8,17 +8,14 @@
 #include <string>
 
 #include "base/callback_list.h"
+#include "base/values.h"
 #include "gin/handle.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_change_dispatcher.h"
 #include "shell/browser/event_emitter_mixin.h"
 #include "shell/common/gin_helper/promise.h"
 #include "shell/common/gin_helper/trackable_object.h"
 
-namespace base {
-class DictionaryValue;
-}
-
 namespace gin_helper {
 class Dictionary;
 }
@@ -51,8 +48,7 @@ class Cookies : public gin::Wrappable<Cookies>,
 
   v8::Local<v8::Promise> Get(v8::Isolate*,
                              const gin_helper::Dictionary& filter);
-  v8::Local<v8::Promise> Set(v8::Isolate*,
-                             const base::DictionaryValue& details);
+  v8::Local<v8::Promise> Set(v8::Isolate*, base::Value::Dict details);
   v8::Local<v8::Promise> Remove(v8::Isolate*,
                                 const GURL& url,
                                 const std::string& name);

shell/browser/api/electron_api_debugger.cc

@@ -45,44 +45,35 @@ void Debugger::DispatchProtocolMessage(DevToolsAgentHost* agent_host,
 
   base::StringPiece message_str(reinterpret_cast<const char*>(message.data()),
                                 message.size());
-  std::unique_ptr<base::Value> parsed_message =
-      base::JSONReader::ReadDeprecated(message_str,
-                                       base::JSON_REPLACE_INVALID_CHARACTERS);
+  absl::optional<base::Value> parsed_message = base::JSONReader::Read(
+      message_str, base::JSON_REPLACE_INVALID_CHARACTERS);
   if (!parsed_message || !parsed_message->is_dict())
     return;
-  auto* dict = static_cast<base::DictionaryValue*>(parsed_message.get());
-  int id;
-  if (!dict->GetInteger("id", &id)) {
-    std::string method;
-    if (!dict->GetString("method", &method))
+  base::Value::Dict& dict = parsed_message->GetDict();
+  absl::optional<int> id = dict.FindInt("id");
+  if (!id) {
+    std::string* method = dict.FindString("method");
+    if (!method)
       return;
-    std::string session_id;
-    dict->GetString("sessionId", &session_id);
-    base::DictionaryValue* params_value = nullptr;
-    base::DictionaryValue params;
-    if (dict->GetDictionary("params", &params_value))
-      params.Swap(params_value);
-    Emit("message", method, params, session_id);
+    std::string* session_id = dict.FindString("sessionId");
+    base::Value::Dict* params = dict.FindDict("params");
+    Emit("message", *method, params ? std::move(*params) : base::Value::Dict(),
+         session_id ? *session_id : "");
   } else {
-    auto it = pending_requests_.find(id);
+    auto it = pending_requests_.find(*id);
     if (it == pending_requests_.end())
       return;
 
-    gin_helper::Promise<base::DictionaryValue> promise = std::move(it->second);
+    gin_helper::Promise<base::Value::Dict> promise = std::move(it->second);
     pending_requests_.erase(it);
 
-    base::DictionaryValue* error = nullptr;
-    if (dict->GetDictionary("error", &error)) {
-      std::string message;
-      error->GetString("message", &message);
-      promise.RejectWithErrorMessage(message);
+    base::Value::Dict* error = dict.FindDict("error");
+    if (error) {
+      std::string* message = error->FindString("message");
+      promise.RejectWithErrorMessage(message ? *message : "");
     } else {
-      base::DictionaryValue* result_body = nullptr;
-      base::DictionaryValue result;
-      if (dict->GetDictionary("result", &result_body)) {
-        result.Swap(result_body);
-      }
-      promise.Resolve(result);
+      base::Value::Dict* result = dict.FindDict("result");
+      promise.Resolve(result ? std::move(*result) : base::Value::Dict());
     }
   }
 }
@@ -133,7 +124,7 @@ void Debugger::Detach() {
 
 v8::Local<v8::Promise> Debugger::SendCommand(gin::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
-  gin_helper::Promise<base::DictionaryValue> promise(isolate);
+  gin_helper::Promise<base::Value::Dict> promise(isolate);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   if (!agent_host_) {
@@ -147,7 +138,7 @@ v8::Local<v8::Promise> Debugger::SendCommand(gin::Arguments* args) {
     return handle;
   }
 
-  base::DictionaryValue command_params;
+  base::Value::Dict command_params;
   args->GetNext(&command_params);
 
   std::string session_id;
@@ -156,22 +147,21 @@ v8::Local<v8::Promise> Debugger::SendCommand(gin::Arguments* args) {
     return handle;
   }
 
-  base::DictionaryValue request;
+  base::Value::Dict request;
   int request_id = ++previous_request_id_;
   pending_requests_.emplace(request_id, std::move(promise));
-  request.SetInteger("id", request_id);
-  request.SetString("method", method);
-  if (!command_params.DictEmpty()) {
-    request.Set("params",
-                base::Value::ToUniquePtrValue(command_params.Clone()));
+  request.Set("id", request_id);
+  request.Set("method", method);
+  if (!command_params.empty()) {
+    request.Set("params", base::Value(std::move(command_params)));
   }
 
   if (!session_id.empty()) {
-    request.SetString("sessionId", session_id);
+    request.Set("sessionId", session_id);
   }
 
   std::string json_args;
-  base::JSONWriter::Write(request, &json_args);
+  base::JSONWriter::Write(base::Value(std::move(request)), &json_args);
   agent_host_->DispatchProtocolMessage(
       this, base::as_bytes(base::make_span(json_args)));
 

shell/browser/api/electron_api_debugger.h

@@ -57,7 +57,7 @@ class Debugger : public gin::Wrappable<Debugger>,
 
  private:
   using PendingRequestMap =
-      std::map<int, gin_helper::Promise<base::DictionaryValue>>;
+      std::map<int, gin_helper::Promise<base::Value::Dict>>;
 
   void Attach(gin::Arguments* args);
   bool IsAttached();

shell/browser/api/electron_api_session.cc

@@ -1160,7 +1160,7 @@ gin::Handle<Session> Session::CreateFrom(
 // static
 gin::Handle<Session> Session::FromPartition(v8::Isolate* isolate,
                                             const std::string& partition,
-                                            base::DictionaryValue options) {
+                                            base::Value::Dict options) {
   ElectronBrowserContext* browser_context;
   if (partition.empty()) {
     browser_context =
@@ -1265,7 +1265,7 @@ v8::Local<v8::Value> FromPartition(const std::string& partition,
     args->ThrowTypeError("Session can only be received when app is ready");
     return v8::Null(args->isolate());
   }
-  base::DictionaryValue options;
+  base::Value::Dict options;
   args->GetNext(&options);
   return Session::FromPartition(args->isolate(), partition, std::move(options))
       .ToV8();

shell/browser/api/electron_api_session.h

@@ -75,10 +75,9 @@ class Session : public gin::Wrappable<Session>,
   static Session* FromBrowserContext(content::BrowserContext* context);
 
   // Gets the Session of |partition|.
-  static gin::Handle<Session> FromPartition(
-      v8::Isolate* isolate,
-      const std::string& partition,
-      base::DictionaryValue options = base::DictionaryValue());
+  static gin::Handle<Session> FromPartition(v8::Isolate* isolate,
+                                            const std::string& partition,
+                                            base::Value::Dict options = {});
 
   ElectronBrowserContext* browser_context() const { return browser_context_; }
 

shell/browser/api/electron_api_system_preferences.h

@@ -72,18 +72,18 @@ class SystemPreferences
       void(const std::string&, base::Value, const std::string&)>;
 
   void PostNotification(const std::string& name,
-                        base::DictionaryValue user_info,
+                        base::Value::Dict user_info,
                         gin::Arguments* args);
   int SubscribeNotification(v8::Local<v8::Value> maybe_name,
                             const NotificationCallback& callback);
   void UnsubscribeNotification(int id);
   void PostLocalNotification(const std::string& name,
-                             base::DictionaryValue user_info);
+                             base::Value::Dict user_info);
   int SubscribeLocalNotification(v8::Local<v8::Value> maybe_name,
                                  const NotificationCallback& callback);
   void UnsubscribeLocalNotification(int request_id);
   void PostWorkspaceNotification(const std::string& name,
-                                 base::DictionaryValue user_info);
+                                 base::Value::Dict user_info);
   int SubscribeWorkspaceNotification(v8::Local<v8::Value> maybe_name,
                                      const NotificationCallback& callback);
   void UnsubscribeWorkspaceNotification(int request_id);