mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

chore: modernize Value usage in converters (#34794)

Browse source 
* chore: modernize Value usage in converters

* Date is parsed as an empty object now
This commit is contained in:
Jeremy Rose 2022-07-05 08:25:18 -07:00 • committed by GitHub
commit 0ee7f14190
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
34 changed files with 203 additions and 829 deletions
Download patch file Download diff file Expand all files Collapse all files

2
filenames.gni
View file

@ -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",

2
shell/browser/api/electron_api_base_window.cc
View file

@ -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);
}

2
shell/browser/api/electron_api_base_window.h
View file

@ -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)

5
shell/browser/api/electron_api_content_tracing.cc
View file

@ -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;
}

47
shell/browser/api/electron_api_cookies.cc
View file

@ -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()) {

8
shell/browser/api/electron_api_cookies.h
View file

@ -8,6 +8,7 @@
#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"
@ -15,10 +16,6 @@
#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);

66
shell/browser/api/electron_api_debugger.cc
View file

@ -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)));

2
shell/browser/api/electron_api_debugger.h
View file

@ -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();

4
shell/browser/api/electron_api_session.cc
View file

@ -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();

5
shell/browser/api/electron_api_session.h
View file

@ -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,
static gin::Handle<Session> FromPartition(v8::Isolate* isolate,
const std::string& partition,
base::DictionaryValue options = base::DictionaryValue());
base::Value::Dict options = {});
ElectronBrowserContext* browser_context() const { return browser_context_; }

6
shell/browser/api/electron_api_system_preferences.h
View file

@ -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);

25
shell/browser/api/electron_api_system_preferences_mac.mm
View file

@ -138,7 +138,7 @@ NSNotificationCenter* GetNotificationCenter(NotificationCenterKind kind) {
} // namespace
void SystemPreferences::PostNotification(const std::string& name,
base::DictionaryValue user_info,
base::Value::Dict user_info,
gin::Arguments* args) {
bool immediate = false;
args->GetNext(&immediate);
@ -148,7 +148,7 @@ void SystemPreferences::PostNotification(const std::string& name,
[center
postNotificationName:base::SysUTF8ToNSString(name)
object:nil
userInfo:DictionaryValueToNSDictionary(user_info.GetDict())
userInfo:DictionaryValueToNSDictionary(std::move(user_info))
deliverImmediately:immediate];
}
@ -166,12 +166,12 @@ void SystemPreferences::UnsubscribeNotification(int request_id) {
}
void SystemPreferences::PostLocalNotification(const std::string& name,
base::DictionaryValue user_info) {
base::Value::Dict user_info) {
NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
[center
postNotificationName:base::SysUTF8ToNSString(name)
object:nil
userInfo:DictionaryValueToNSDictionary(user_info.GetDict())];
userInfo:DictionaryValueToNSDictionary(std::move(user_info))];
}
int SystemPreferences::SubscribeLocalNotification(
@ -186,15 +186,14 @@ void SystemPreferences::UnsubscribeLocalNotification(int request_id) {
NotificationCenterKind::kNSNotificationCenter);
}
void SystemPreferences::PostWorkspaceNotification(
const std::string& name,
base::DictionaryValue user_info) {
void SystemPreferences::PostWorkspaceNotification(const std::string& name,
base::Value::Dict user_info) {
NSNotificationCenter* center =
[[NSWorkspace sharedWorkspace] notificationCenter];
[center
postNotificationName:base::SysUTF8ToNSString(name)
object:nil
userInfo:DictionaryValueToNSDictionary(user_info.GetDict())];
userInfo:DictionaryValueToNSDictionary(std::move(user_info))];
}
int SystemPreferences::SubscribeWorkspaceNotification(
@ -246,7 +245,7 @@ int SystemPreferences::DoSubscribeNotification(
} else {
copied_callback.Run(
base::SysNSStringToUTF8(notification.name),
base::DictionaryValue(), object);
base::Value(base::Value::Dict()), object);
}
}];
return request_id;
@ -295,13 +294,14 @@ v8::Local<v8::Value> SystemPreferences::GetUserDefault(
}
void SystemPreferences::RegisterDefaults(gin::Arguments* args) {
base::DictionaryValue value;
base::Value::Dict value;
if (!args->GetNext(&value)) {
args->ThrowError();
} else {
return;
}
@try {
NSDictionary* dict = DictionaryValueToNSDictionary(value.GetDict());
NSDictionary* dict = DictionaryValueToNSDictionary(std::move(value));
for (id key in dict) {
id value = [dict objectForKey:key];
if ([value isKindOfClass:[NSNull class]] || value == nil) {
@ -313,7 +313,6 @@ void SystemPreferences::RegisterDefaults(gin::Arguments* args) {
} @catch (NSException* exception) {
args->ThrowError();
}
}
}
void SystemPreferences::SetUserDefault(const std::string& name,

6
shell/browser/browser.h
View file

@ -165,7 +165,7 @@ class Browser : public WindowListObserver {
// Creates an activity and sets it as the one currently in use.
void SetUserActivity(const std::string& type,
base::DictionaryValue user_info,
base::Value::Dict user_info,
gin::Arguments* args);
// Returns the type name of the current user activity.
@ -180,7 +180,7 @@ class Browser : public WindowListObserver {
// Updates the current user activity
void UpdateCurrentActivity(const std::string& type,
base::DictionaryValue user_info);
base::Value::Dict user_info);
// Indicates that an user activity is about to be resumed.
bool WillContinueUserActivity(const std::string& type);
@ -231,7 +231,7 @@ class Browser : public WindowListObserver {
#endif // BUILDFLAG(IS_MAC)
void ShowAboutPanel();
void SetAboutPanelOptions(base::DictionaryValue options);
void SetAboutPanelOptions(base::Value::Dict options);
#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN)
void ShowEmojiPanel();

4
shell/browser/browser_linux.cc
View file

@ -224,8 +224,8 @@ void Browser::ShowAboutPanel() {
gtk_widget_destroy(dialogWidget);
}
void Browser::SetAboutPanelOptions(base::DictionaryValue options) {
about_panel_options_ = std::move(options);
void Browser::SetAboutPanelOptions(base::Value::Dict options) {
about_panel_options_ = base::Value(std::move(options));
}
} // namespace electron

15
shell/browser/browser_mac.mm
View file

@ -235,14 +235,14 @@ bool Browser::SetBadgeCount(absl::optional<int> count) {
}
void Browser::SetUserActivity(const std::string& type,
base::DictionaryValue user_info,
base::Value::Dict user_info,
gin::Arguments* args) {
std::string url_string;
args->GetNext(&url_string);
[[AtomApplication sharedApplication]
setCurrentActivity:base::SysUTF8ToNSString(type)
withUserInfo:DictionaryValueToNSDictionary(user_info.GetDict())
withUserInfo:DictionaryValueToNSDictionary(std::move(user_info))
withWebpageURL:net::NSURLWithGURL(GURL(url_string))];
}
@ -261,10 +261,11 @@ void Browser::ResignCurrentActivity() {
}
void Browser::UpdateCurrentActivity(const std::string& type,
base::DictionaryValue user_info) {
base::Value::Dict user_info) {
[[AtomApplication sharedApplication]
updateCurrentActivity:base::SysUTF8ToNSString(type)
withUserInfo:DictionaryValueToNSDictionary(user_info.GetDict())];
withUserInfo:DictionaryValueToNSDictionary(
std::move(user_info))];
}
bool Browser::WillContinueUserActivity(const std::string& type) {
@ -511,11 +512,11 @@ void Browser::ShowAboutPanel() {
orderFrontStandardAboutPanelWithOptions:options];
}
void Browser::SetAboutPanelOptions(base::DictionaryValue options) {
void Browser::SetAboutPanelOptions(base::Value::Dict options) {
about_panel_options_.DictClear();
for (const auto pair : options.DictItems()) {
std::string key = std::string(pair.first);
for (const auto pair : options) {
std::string key = pair.first;
if (!key.empty() && pair.second.is_string()) {
key[0] = base::ToUpperASCII(key[0]);
auto val = std::make_unique<base::Value>(pair.second.Clone());

4
shell/browser/browser_win.cc
View file

@ -851,8 +851,8 @@ void Browser::ShowAboutPanel() {
electron::ShowMessageBoxSync(settings);
}
void Browser::SetAboutPanelOptions(base::DictionaryValue options) {
about_panel_options_ = std::move(options);
void Browser::SetAboutPanelOptions(base::Value::Dict options) {
about_panel_options_ = base::Value(std::move(options));
}
} // namespace electron

6
shell/browser/electron_browser_context.cc
View file

@ -103,7 +103,7 @@ ElectronBrowserContext::browser_context_map() {
ElectronBrowserContext::ElectronBrowserContext(const std::string& partition,
bool in_memory,
base::DictionaryValue options)
base::Value::Dict options)
: storage_policy_(base::MakeRefCounted<SpecialStoragePolicy>()),
protocol_registry_(base::WrapUnique(new ProtocolRegistry)),
in_memory_(in_memory),
@ -111,7 +111,7 @@ ElectronBrowserContext::ElectronBrowserContext(const std::string& partition,
// Read options.
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
use_cache_ = !command_line->HasSwitch(switches::kDisableHttpCache);
if (auto use_cache_opt = options.FindBoolKey("cache")) {
if (auto use_cache_opt = options.FindBool("cache")) {
use_cache_ = use_cache_opt.value();
}
@ -530,7 +530,7 @@ bool ElectronBrowserContext::CheckDevicePermission(
ElectronBrowserContext* ElectronBrowserContext::From(
const std::string& partition,
bool in_memory,
base::DictionaryValue options) {
base::Value::Dict options) {
PartitionKey key(partition, in_memory);
ElectronBrowserContext* browser_context = browser_context_map()[key].get();
if (browser_context) {

8
shell/browser/electron_browser_context.h
View file

@ -44,7 +44,6 @@ using DevicePermissionMap =
std::map<blink::PermissionType,
std::map<url::Origin, std::vector<std::unique_ptr<base::Value>>>>;
class ElectronBrowserContext;
class ElectronDownloadManagerDelegate;
class ElectronPermissionManager;
class CookieChangeNotifier;
@ -82,10 +81,9 @@ class ElectronBrowserContext : public content::BrowserContext {
// Get or create the BrowserContext according to its |partition| and
// |in_memory|. The |options| will be passed to constructor when there is no
// existing BrowserContext.
static ElectronBrowserContext* From(
const std::string& partition,
static ElectronBrowserContext* From(const std::string& partition,
bool in_memory,
base::DictionaryValue options = base::DictionaryValue());
base::Value::Dict options = {});
static BrowserContextMap& browser_context_map();
@ -177,7 +175,7 @@ class ElectronBrowserContext : public content::BrowserContext {
private:
ElectronBrowserContext(const std::string& partition,
bool in_memory,
base::DictionaryValue options);
base::Value::Dict options);
// Initialize pref registry.
void InitPrefs();

5
shell/browser/native_window.cc
View file

@ -658,9 +658,8 @@ void NativeWindow::NotifyWindowExecuteAppCommand(const std::string& command) {
observer.OnExecuteAppCommand(command);
}
void NativeWindow::NotifyTouchBarItemInteraction(
const std::string& item_id,
const base::DictionaryValue& details) {
void NativeWindow::NotifyTouchBarItemInteraction(const std::string& item_id,
base::Value::Dict details) {
for (NativeWindowObserver& observer : observers_)
observer.OnTouchBarItemResult(item_id, details);
}

2
shell/browser/native_window.h
View file

@ -304,7 +304,7 @@ class NativeWindow : public base::SupportsUserData,
void NotifyWindowAlwaysOnTopChanged();
void NotifyWindowExecuteAppCommand(const std::string& command);
void NotifyTouchBarItemInteraction(const std::string& item_id,
const base::DictionaryValue& details);
base::Value::Dict details);
void NotifyNewWindowForTab();
void NotifyWindowSystemContextMenu(int x, int y, bool* prevent_default);
void NotifyLayoutWindowControlsOverlay();

2
shell/browser/native_window_observer.h
View file

@ -93,7 +93,7 @@ class NativeWindowObserver : public base::CheckedObserver {
virtual void OnWindowLeaveHtmlFullScreen() {}
virtual void OnWindowAlwaysOnTopChanged() {}
virtual void OnTouchBarItemResult(const std::string& item_id,
const base::DictionaryValue& details) {}
const base::Value::Dict& details) {}
virtual void OnNewWindowForTab() {}
virtual void OnSystemContextMenu(int x, int y, bool* prevent_default) {}

6
shell/browser/net/electron_url_loader_factory.cc
View file

@ -114,9 +114,9 @@ network::mojom::URLResponseHeadPtr ToResponseHead(
bool has_mime_type = dict.Get("mimeType", &head->mime_type);
bool has_content_type = false;
base::DictionaryValue headers;
base::Value::Dict headers;
if (dict.Get("headers", &headers)) {
for (const auto iter : headers.DictItems()) {
for (const auto iter : headers) {
if (iter.second.is_string()) {
// key, value
head->headers->AddHeader(iter.first, iter.second.GetString());
@ -513,7 +513,7 @@ void ElectronURLLoaderFactory::StartLoadingHttp(
if (!dict.Get("method", &request->method))
request->method = original_request.method;
base::DictionaryValue upload_data;
base::Value::Dict upload_data;
if (request->method != net::HttpRequestHeaders::kGetMethod &&
request->method != net::HttpRequestHeaders::kHeadMethod)
dict.Get("uploadData", &upload_data);

12
shell/browser/net/url_pipe_loader.cc
View file

@ -19,7 +19,7 @@ URLPipeLoader::URLPipeLoader(
mojo::PendingReceiver<network::mojom::URLLoader> loader,
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
const net::NetworkTrafficAnnotationTag& annotation,
base::DictionaryValue upload_data)
base::Value::Dict upload_data)
: url_loader_(this, std::move(loader)), client_(std::move(client)) {
url_loader_.set_disconnect_handler(base::BindOnce(
&URLPipeLoader::NotifyComplete, base::Unretained(this), net::ERR_FAILED));
@ -37,17 +37,17 @@ void URLPipeLoader::Start(
scoped_refptr<network::SharedURLLoaderFactory> factory,
std::unique_ptr<network::ResourceRequest> request,
const net::NetworkTrafficAnnotationTag& annotation,
base::DictionaryValue upload_data) {
base::Value::Dict upload_data) {
loader_ = network::SimpleURLLoader::Create(std::move(request), annotation);
loader_->SetOnResponseStartedCallback(base::BindOnce(
&URLPipeLoader::OnResponseStarted, weak_factory_.GetWeakPtr()));
// TODO(zcbenz): The old protocol API only supports string as upload data,
// we should seek to support more types in future.
std::string content_type, data;
if (upload_data.GetString("contentType", &content_type) &&
upload_data.GetString("data", &data))
loader_->AttachStringForUpload(data, content_type);
std::string* content_type = upload_data.FindString("contentType");
std::string* data = upload_data.FindString("data");
if (content_type && data)
loader_->AttachStringForUpload(*data, *content_type);
loader_->DownloadAsStream(factory.get(), this);
}

4
shell/browser/net/url_pipe_loader.h
View file

@ -39,7 +39,7 @@ class URLPipeLoader : public network::mojom::URLLoader,
mojo::PendingReceiver<network::mojom::URLLoader> loader,
mojo::PendingRemote<network::mojom::URLLoaderClient> client,
const net::NetworkTrafficAnnotationTag& annotation,
base::DictionaryValue upload_data);
base::Value::Dict upload_data);
// disable copy
URLPipeLoader(const URLPipeLoader&) = delete;
@ -51,7 +51,7 @@ class URLPipeLoader : public network::mojom::URLLoader,
void Start(scoped_refptr<network::SharedURLLoaderFactory> factory,
std::unique_ptr<network::ResourceRequest> request,
const net::NetworkTrafficAnnotationTag& annotation,
base::DictionaryValue upload_data);
base::Value::Dict upload_data);
void NotifyComplete(int result);
void OnResponseStarted(const GURL& final_url,
const network::mojom::URLResponseHead& response_head);

45
shell/browser/ui/cocoa/electron_touch_bar.mm
View file

@ -241,8 +241,7 @@ static NSString* const ImageScrubberItemIdentifier = @"scrubber.image.item";
- (void)buttonAction:(id)sender {
NSString* item_id =
[NSString stringWithFormat:@"%ld", ((NSButton*)sender).tag];
window_->NotifyTouchBarItemInteraction([item_id UTF8String],
base::DictionaryValue());
window_->NotifyTouchBarItemInteraction([item_id UTF8String], {});
}
- (void)colorPickerAction:(id)sender {
@ -252,19 +251,20 @@ static NSString* const ImageScrubberItemIdentifier = @"scrubber.image.item";
NSColor* color = ((NSColorPickerTouchBarItem*)sender).color;
std::string hex_color =
electron::ToRGBHex(skia::NSDeviceColorToSkColor(color));
base::DictionaryValue details;
details.SetString("color", hex_color);
window_->NotifyTouchBarItemInteraction([item_id UTF8String], details);
base::Value::Dict details;
details.Set("color", hex_color);
window_->NotifyTouchBarItemInteraction([item_id UTF8String],
std::move(details));
}
- (void)sliderAction:(id)sender {
NSString* identifier = ((NSSliderTouchBarItem*)sender).identifier;
NSString* item_id = [self idFromIdentifier:identifier
withPrefix:SliderIdentifier];
base::DictionaryValue details;
details.SetInteger("value",
[((NSSliderTouchBarItem*)sender).slider intValue]);
window_->NotifyTouchBarItemInteraction([item_id UTF8String], details);
base::Value::Dict details;
details.Set("value", [((NSSliderTouchBarItem*)sender).slider intValue]);
window_->NotifyTouchBarItemInteraction([item_id UTF8String],
std::move(details));
}
- (NSString*)idFromIdentifier:(NSString*)identifier
@ -275,32 +275,33 @@ static NSString* const ImageScrubberItemIdentifier = @"scrubber.image.item";
- (void)segmentedControlAction:(id)sender {
NSString* item_id =
[NSString stringWithFormat:@"%ld", ((NSSegmentedControl*)sender).tag];
base::DictionaryValue details;
details.SetInteger("selectedIndex",
((NSSegmentedControl*)sender).selectedSegment);
details.SetBoolean(
base::Value::Dict details;
details.Set("selectedIndex",
static_cast<int>(((NSSegmentedControl*)sender).selectedSegment));
details.Set(
"isSelected",
[((NSSegmentedControl*)sender)
isSelectedForSegment:((NSSegmentedControl*)sender).selectedSegment]);
window_->NotifyTouchBarItemInteraction([item_id UTF8String], details);
window_->NotifyTouchBarItemInteraction([item_id UTF8String],
std::move(details));
}
- (void)scrubber:(NSScrubber*)scrubber
didSelectItemAtIndex:(NSInteger)selectedIndex {
base::DictionaryValue details;
details.SetInteger("selectedIndex", selectedIndex);
details.SetString("type", "select");
base::Value::Dict details;
details.Set("selectedIndex", static_cast<int>(selectedIndex));
details.Set("type", "select");
window_->NotifyTouchBarItemInteraction([scrubber.identifier UTF8String],
details);
std::move(details));
}
- (void)scrubber:(NSScrubber*)scrubber
didHighlightItemAtIndex:(NSInteger)highlightedIndex {
base::DictionaryValue details;
details.SetInteger("highlightedIndex", highlightedIndex);
details.SetString("type", "highlight");
base::Value::Dict details;
details.Set("highlightedIndex", static_cast<int>(highlightedIndex));
details.Set("type", "highlight");
window_->NotifyTouchBarItemInteraction([scrubber.identifier UTF8String],
details);
std::move(details));
}
- (NSTouchBarItemIdentifier)identifierFromID:(const std::string&)item_id

21
shell/common/api/electron_api_native_image.cc
View file

@ -329,24 +329,24 @@ float NativeImage::GetAspectRatio(const absl::optional<float> scale_factor) {
}
gin::Handle<NativeImage> NativeImage::Resize(gin::Arguments* args,
base::DictionaryValue options) {
base::Value::Dict options) {
float scale_factor = GetScaleFactorFromOptions(args);
gfx::Size size = GetSize(scale_factor);
int width = size.width();
int height = size.height();
bool width_set = options.GetInteger("width", &width);
bool height_set = options.GetInteger("height", &height);
absl::optional<int> new_width = options.FindInt("width");
absl::optional<int> new_height = options.FindInt("height");
int width = new_width.value_or(size.width());
int height = new_height.value_or(size.height());
size.SetSize(width, height);
if (width <= 0 && height <= 0) {
return CreateEmpty(args->isolate());
} else if (width_set && !height_set) {
} else if (new_width && !new_height) {
// Scale height to preserve original aspect ratio
size.set_height(width);
size =
gfx::ScaleToRoundedSize(size, 1.f, 1.f / GetAspectRatio(scale_factor));
} else if (height_set && !width_set) {
} else if (new_height && !new_width) {
// Scale width to preserve original aspect ratio
size.set_width(height);
size = gfx::ScaleToRoundedSize(size, GetAspectRatio(scale_factor), 1.f);
@ -354,11 +354,10 @@ gin::Handle<NativeImage> NativeImage::Resize(gin::Arguments* args,
skia::ImageOperations::ResizeMethod method =
skia::ImageOperations::ResizeMethod::RESIZE_BEST;
std::string quality;
options.GetString("quality", &quality);
if (quality == "good")
std::string* quality = options.FindString("quality");
if (quality && *quality == "good")
method = skia::ImageOperations::ResizeMethod::RESIZE_GOOD;
else if (quality == "better")
else if (quality && *quality == "better")
method = skia::ImageOperations::ResizeMethod::RESIZE_BETTER;
gfx::ImageSkia resized = gfx::ImageSkiaOperations::CreateResizedImage(

2
shell/common/api/electron_api_native_image.h
View file

@ -112,7 +112,7 @@ class NativeImage : public gin::Wrappable<NativeImage> {
v8::Local<v8::Value> GetBitmap(gin::Arguments* args);
v8::Local<v8::Value> GetNativeHandle(gin_helper::ErrorThrower thrower);
gin::Handle<NativeImage> Resize(gin::Arguments* args,
base::DictionaryValue options);
base::Value::Dict options);
gin::Handle<NativeImage> Crop(v8::Isolate* isolate, const gfx::Rect& rect);
std::string ToDataURL(gin::Arguments* args);
bool IsEmpty();

3
shell/common/gin_converters/extension_converter.cc
View file

@ -22,7 +22,8 @@ v8::Local<v8::Value> Converter<const extensions::Extension*>::ToV8(
dict.Set("path", extension->path());
dict.Set("url", extension->url());
dict.Set("version", extension->VersionString());
dict.Set("manifest", *(extension->manifest()->value()));
dict.Set("manifest",
*static_cast<const base::Value*>(extension->manifest()->value()));
return gin::ConvertToV8(isolate, dict);
}

10
shell/common/gin_converters/net_converter.cc
View file

@ -234,13 +234,13 @@ v8::Local<v8::Value> Converter<net::HttpRequestHeaders>::ToV8(
bool Converter<net::HttpRequestHeaders>::FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
net::HttpRequestHeaders* out) {
base::DictionaryValue dict;
base::Value::Dict dict;
if (!ConvertFromV8(isolate, val, &dict))
return false;
for (base::DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
if (it.value().is_string()) {
std::string value = it.value().GetString();
out->SetHeader(it.key(), value);
for (const auto it : dict) {
if (it.second.is_string()) {
std::string value = it.second.GetString();
out->SetHeader(it.first, value);
}
}
return true;

55
shell/common/gin_converters/value_converter.cc
View file

@ -7,38 +7,38 @@
#include <memory>
#include <utility>
#include "base/values.h"
#include "shell/common/v8_value_converter.h"
#include "content/public/renderer/v8_value_converter.h"
namespace gin {
bool Converter<base::DictionaryValue>::FromV8(v8::Isolate* isolate,
bool Converter<base::Value::Dict>::FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
base::DictionaryValue* out) {
electron::V8ValueConverter converter;
std::unique_ptr<base::Value> value(
converter.FromV8Value(val, isolate->GetCurrentContext()));
base::Value::Dict* out) {
std::unique_ptr<base::Value> value =
content::V8ValueConverter::Create()->FromV8Value(
val, isolate->GetCurrentContext());
if (value && value->is_dict()) {
out->Swap(static_cast<base::DictionaryValue*>(value.get()));
*out = std::move(value->GetDict());
return true;
} else {
return false;
}
}
v8::Local<v8::Value> Converter<base::DictionaryValue>::ToV8(
v8::Local<v8::Value> Converter<base::Value::Dict>::ToV8(
v8::Isolate* isolate,
const base::DictionaryValue& val) {
electron::V8ValueConverter converter;
return converter.ToV8Value(&val, isolate->GetCurrentContext());
const base::Value::Dict& val) {
base::Value value(val.Clone());
return content::V8ValueConverter::Create()->ToV8Value(
&value, isolate->GetCurrentContext());
}
bool Converter<base::Value>::FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
base::Value* out) {
electron::V8ValueConverter converter;
std::unique_ptr<base::Value> value(
converter.FromV8Value(val, isolate->GetCurrentContext()));
std::unique_ptr<base::Value> value =
content::V8ValueConverter::Create()->FromV8Value(
val, isolate->GetCurrentContext());
if (value) {
*out = std::move(*value);
return true;
@ -49,29 +49,30 @@ bool Converter<base::Value>::FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> Converter<base::Value>::ToV8(v8::Isolate* isolate,
const base::Value& val) {
electron::V8ValueConverter converter;
return converter.ToV8Value(&val, isolate->GetCurrentContext());
return content::V8ValueConverter::Create()->ToV8Value(
&val, isolate->GetCurrentContext());
}
bool Converter<base::ListValue>::FromV8(v8::Isolate* isolate,
bool Converter<base::Value::List>::FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
base::ListValue* out) {
electron::V8ValueConverter converter;
std::unique_ptr<base::Value> value(
converter.FromV8Value(val, isolate->GetCurrentContext()));
base::Value::List* out) {
std::unique_ptr<base::Value> value =
content::V8ValueConverter::Create()->FromV8Value(
val, isolate->GetCurrentContext());
if (value && value->is_list()) {
out->Swap(static_cast<base::ListValue*>(value.get()));
*out = std::move(value->GetList());
return true;
} else {
return false;
}
}
v8::Local<v8::Value> Converter<base::ListValue>::ToV8(
v8::Local<v8::Value> Converter<base::Value::List>::ToV8(
v8::Isolate* isolate,
const base::ListValue& val) {
electron::V8ValueConverter converter;
return converter.ToV8Value(&val, isolate->GetCurrentContext());
const base::Value::List& val) {
base::Value value(val.Clone());
return content::V8ValueConverter::Create()->ToV8Value(
&value, isolate->GetCurrentContext());
}
} // namespace gin

19
shell/common/gin_converters/value_converter.h
View file

@ -5,23 +5,18 @@
#ifndef ELECTRON_SHELL_COMMON_GIN_CONVERTERS_VALUE_CONVERTER_H_
#define ELECTRON_SHELL_COMMON_GIN_CONVERTERS_VALUE_CONVERTER_H_
#include "base/values.h"
#include "gin/converter.h"
namespace base {
class DictionaryValue;
class ListValue;
class Value;
} // namespace base
namespace gin {
template <>
struct Converter<base::DictionaryValue> {
struct Converter<base::Value::Dict> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
base::DictionaryValue* out);
base::Value::Dict* out);
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
const base::DictionaryValue& val);
const base::Value::Dict& val);
};
template <>
@ -34,12 +29,12 @@ struct Converter<base::Value> {
};
template <>
struct Converter<base::ListValue> {
struct Converter<base::Value::List> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
base::ListValue* out);
base::Value::List* out);
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
const base::ListValue& val);
const base::Value::List& val);
};
} // namespace gin

524
shell/common/v8_value_converter.cc
View file

@ -1,524 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/common/v8_value_converter.h"
#include <iterator>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "base/logging.h"
#include "base/values.h"
#include "shell/common/gin_helper/dictionary.h"
#include "shell/common/node_bindings.h"
#include "shell/common/node_includes.h"
namespace electron {
namespace {
const int kMaxRecursionDepth = 100;
} // namespace
// The state of a call to FromV8Value.
class V8ValueConverter::FromV8ValueState {
public:
// Level scope which updates the current depth of some FromV8ValueState.
class Level {
public:
explicit Level(FromV8ValueState* state) : state_(state) {
state_->max_recursion_depth_--;
}
~Level() { state_->max_recursion_depth_++; }
private:
FromV8ValueState* state_;
};
FromV8ValueState() : max_recursion_depth_(kMaxRecursionDepth) {}
// If |handle| is not in |unique_map_|, then add it to |unique_map_| and
// return true.
//
// Otherwise do nothing and return false. Here "A is unique" means that no
// other handle B in the map points to the same object as A. Note that A can
// be unique even if there already is another handle with the same identity
// hash (key) in the map, because two objects can have the same hash.
bool AddToUniquenessCheck(v8::Local<v8::Object> handle) {
int hash;
auto iter = GetIteratorInMap(handle, &hash);
if (iter != unique_map_.end())
return false;
unique_map_.insert(std::make_pair(hash, handle));
return true;
}
bool RemoveFromUniquenessCheck(v8::Local<v8::Object> handle) {
int unused_hash;
auto iter = GetIteratorInMap(handle, &unused_hash);
if (iter == unique_map_.end())
return false;
unique_map_.erase(iter);
return true;
}
bool HasReachedMaxRecursionDepth() { return max_recursion_depth_ < 0; }
private:
using HashToHandleMap = std::multimap<int, v8::Local<v8::Object>>;
using Iterator = HashToHandleMap::const_iterator;
Iterator GetIteratorInMap(v8::Local<v8::Object> handle, int* hash) {
*hash = handle->GetIdentityHash();
// We only compare using == with handles to objects with the same identity
// hash. Different hash obviously means different objects, but two objects
// in a couple of thousands could have the same identity hash.
std::pair<Iterator, Iterator> range = unique_map_.equal_range(*hash);
for (auto it = range.first; it != range.second; ++it) {
// Operator == for handles actually compares the underlying objects.
if (it->second == handle)
return it;
}
// Not found.
return unique_map_.end();
}
HashToHandleMap unique_map_;
int max_recursion_depth_;
};
// A class to ensure that objects/arrays that are being converted by
// this V8ValueConverterImpl do not have cycles.
//
// An example of cycle: var v = {}; v = {key: v};
// Not an example of cycle: var v = {}; a = [v, v]; or w = {a: v, b: v};
class V8ValueConverter::ScopedUniquenessGuard {
public:
ScopedUniquenessGuard(V8ValueConverter::FromV8ValueState* state,
v8::Local<v8::Object> value)
: state_(state),
value_(value),
is_valid_(state_->AddToUniquenessCheck(value_)) {}
~ScopedUniquenessGuard() {
if (is_valid_) {
bool removed = state_->RemoveFromUniquenessCheck(value_);
DCHECK(removed);
}
}
// disable copy
ScopedUniquenessGuard(const ScopedUniquenessGuard&) = delete;
ScopedUniquenessGuard& operator=(const ScopedUniquenessGuard&) = delete;
bool is_valid() const { return is_valid_; }
private:
typedef std::multimap<int, v8::Local<v8::Object>> HashToHandleMap;
V8ValueConverter::FromV8ValueState* state_;
v8::Local<v8::Object> value_;
bool is_valid_;
};
V8ValueConverter::V8ValueConverter() = default;
void V8ValueConverter::SetRegExpAllowed(bool val) {
reg_exp_allowed_ = val;
}
void V8ValueConverter::SetFunctionAllowed(bool val) {
function_allowed_ = val;
}
void V8ValueConverter::SetStripNullFromObjects(bool val) {
strip_null_from_objects_ = val;
}
v8::Local<v8::Value> V8ValueConverter::ToV8Value(
const base::Value* value,
v8::Local<v8::Context> context) const {
v8::Context::Scope context_scope(context);
v8::EscapableHandleScope handle_scope(context->GetIsolate());
return handle_scope.Escape(ToV8ValueImpl(context->GetIsolate(), value));
}
std::unique_ptr<base::Value> V8ValueConverter::FromV8Value(
v8::Local<v8::Value> val,
v8::Local<v8::Context> context) const {
v8::Context::Scope context_scope(context);
v8::HandleScope handle_scope(context->GetIsolate());
FromV8ValueState state;
return FromV8ValueImpl(&state, val, context->GetIsolate());
}
v8::Local<v8::Value> V8ValueConverter::ToV8ValueImpl(
v8::Isolate* isolate,
const base::Value* value) const {
switch (value->type()) {
case base::Value::Type::NONE:
return v8::Null(isolate);
case base::Value::Type::BOOLEAN: {
bool val = value->GetBool();
return v8::Boolean::New(isolate, val);
}
case base::Value::Type::INTEGER: {
int val = value->GetInt();
return v8::Integer::New(isolate, val);
}
case base::Value::Type::DOUBLE: {
double val = value->GetDouble();
return v8::Number::New(isolate, val);
}
case base::Value::Type::STRING: {
std::string val = value->GetString();
return v8::String::NewFromUtf8(isolate, val.c_str(),
v8::NewStringType::kNormal, val.length())
.ToLocalChecked();
}
case base::Value::Type::LIST:
return ToV8Array(isolate, static_cast<const base::ListValue*>(value));
case base::Value::Type::DICTIONARY:
return ToV8Object(isolate,
static_cast<const base::DictionaryValue*>(value));
case base::Value::Type::BINARY:
return ToArrayBuffer(isolate, static_cast<const base::Value*>(value));
default:
LOG(ERROR) << "Unexpected value type: " << value->type();
return v8::Null(isolate);
}
}
v8::Local<v8::Value> V8ValueConverter::ToV8Array(
v8::Isolate* isolate,
const base::ListValue* val) const {
v8::Local<v8::Array> result(
v8::Array::New(isolate, val->GetListDeprecated().size()));
auto context = isolate->GetCurrentContext();
for (size_t i = 0; i < val->GetListDeprecated().size(); ++i) {
const base::Value& child = val->GetListDeprecated()[i];
v8::Local<v8::Value> child_v8 = ToV8ValueImpl(isolate, &child);
v8::TryCatch try_catch(isolate);
result->Set(context, static_cast<uint32_t>(i), child_v8).Check();
if (try_catch.HasCaught())
LOG(ERROR) << "Setter for index " << i << " threw an exception.";
}
return result;
}
v8::Local<v8::Value> V8ValueConverter::ToV8Object(
v8::Isolate* isolate,
const base::DictionaryValue* val) const {
gin_helper::Dictionary result = gin::Dictionary::CreateEmpty(isolate);
result.SetHidden("simple", true);
for (base::DictionaryValue::Iterator iter(*val); !iter.IsAtEnd();
iter.Advance()) {
const std::string& key = iter.key();
v8::Local<v8::Value> child_v8 = ToV8ValueImpl(isolate, &iter.value());
v8::TryCatch try_catch(isolate);
result.Set(key, child_v8);
if (try_catch.HasCaught()) {
LOG(ERROR) << "Setter for property " << key.c_str() << " threw an "
<< "exception.";
}
}
return result.GetHandle();
}
v8::Local<v8::Value> V8ValueConverter::ToArrayBuffer(
v8::Isolate* isolate,
const base::Value* value) const {
const auto* data = reinterpret_cast<const char*>(value->GetBlob().data());
size_t length = value->GetBlob().size();
if (NodeBindings::IsInitialized()) {
return node::Buffer::Copy(isolate, data, length).ToLocalChecked();
}
if (length > node::Buffer::kMaxLength) {
return v8::Local<v8::Object>();
}
auto context = isolate->GetCurrentContext();
auto array_buffer = v8::ArrayBuffer::New(isolate, length);
std::shared_ptr<v8::BackingStore> backing_store =
array_buffer->GetBackingStore();
memcpy(backing_store->Data(), data, length);
// From this point, if something goes wrong(can't find Buffer class for
// example) we'll simply return a Uint8Array based on the created ArrayBuffer.
// This can happen if no preload script was specified to the renderer.
gin_helper::Dictionary global(isolate, context->Global());
v8::Local<v8::Value> buffer_value;
// Get the Buffer class stored as a hidden value in the global object. We'll
// use it return a browserified Buffer.
if (!global.GetHidden("Buffer", &buffer_value) ||
!buffer_value->IsFunction()) {
return v8::Uint8Array::New(array_buffer, 0, length);
}
gin::Dictionary buffer_class(
isolate,
buffer_value->ToObject(isolate->GetCurrentContext()).ToLocalChecked());
v8::Local<v8::Value> from_value;
if (!buffer_class.Get("from", &from_value) || !from_value->IsFunction()) {
return v8::Uint8Array::New(array_buffer, 0, length);
}
v8::Local<v8::Value> args[] = {array_buffer};
auto func = from_value.As<v8::Function>();
auto result = func->Call(context, v8::Null(isolate), std::size(args), args);
if (!result.IsEmpty()) {
return result.ToLocalChecked();
}
return v8::Uint8Array::New(array_buffer, 0, length);
}
std::unique_ptr<base::Value> V8ValueConverter::FromV8ValueImpl(
FromV8ValueState* state,
v8::Local<v8::Value> val,
v8::Isolate* isolate) const {
FromV8ValueState::Level state_level(state);
if (state->HasReachedMaxRecursionDepth())
return nullptr;
if (val->IsExternal())
return std::make_unique<base::Value>();
if (val->IsNull())
return std::make_unique<base::Value>();
auto context = isolate->GetCurrentContext();
if (val->IsBoolean())
return std::make_unique<base::Value>(val->ToBoolean(isolate)->Value());
if (val->IsInt32())
return std::make_unique<base::Value>(val.As<v8::Int32>()->Value());
if (val->IsNumber()) {
double val_as_double = val.As<v8::Number>()->Value();
if (!std::isfinite(val_as_double))
return nullptr;
return std::make_unique<base::Value>(val_as_double);
}
if (val->IsString()) {
v8::String::Utf8Value utf8(isolate, val);
return std::make_unique<base::Value>(std::string(*utf8, utf8.length()));
}
if (val->IsUndefined())
// JSON.stringify ignores undefined.
return nullptr;
if (val->IsDate()) {
v8::Date* date = v8::Date::Cast(*val);
v8::Local<v8::Value> toISOString =
date->Get(context, v8::String::NewFromUtf8(isolate, "toISOString",
v8::NewStringType::kNormal)
.ToLocalChecked())
.ToLocalChecked();
if (toISOString->IsFunction()) {
v8::MaybeLocal<v8::Value> result =
toISOString.As<v8::Function>()->Call(context, val, 0, nullptr);
if (!result.IsEmpty()) {
v8::String::Utf8Value utf8(isolate, result.ToLocalChecked());
return std::make_unique<base::Value>(std::string(*utf8, utf8.length()));
}
}
}
if (val->IsRegExp()) {
if (!reg_exp_allowed_)
// JSON.stringify converts to an object.
return FromV8Object(val.As<v8::Object>(), state, isolate);
return std::make_unique<base::Value>(*v8::String::Utf8Value(isolate, val));
}
// v8::Value doesn't have a ToArray() method for some reason.
if (val->IsArray())
return FromV8Array(val.As<v8::Array>(), state, isolate);
if (val->IsFunction()) {
if (!function_allowed_)
// JSON.stringify refuses to convert function(){}.
return nullptr;
return FromV8Object(val.As<v8::Object>(), state, isolate);
}
if (node::Buffer::HasInstance(val)) {
return FromNodeBuffer(val, state, isolate);
}
if (val->IsObject()) {
return FromV8Object(val.As<v8::Object>(), state, isolate);
}
LOG(ERROR) << "Unexpected v8 value type encountered.";
return nullptr;
}
std::unique_ptr<base::Value> V8ValueConverter::FromV8Array(
v8::Local<v8::Array> val,
FromV8ValueState* state,
v8::Isolate* isolate) const {
ScopedUniquenessGuard uniqueness_guard(state, val);
if (!uniqueness_guard.is_valid())
return std::make_unique<base::Value>();
std::unique_ptr<v8::Context::Scope> scope;
// If val was created in a different context than our current one, change to
// that context, but change back after val is converted.
if (!val->GetCreationContextChecked().IsEmpty() &&
val->GetCreationContextChecked() != isolate->GetCurrentContext())
scope =
std::make_unique<v8::Context::Scope>(val->GetCreationContextChecked());
std::unique_ptr<base::ListValue> result(new base::ListValue());
// Only fields with integer keys are carried over to the ListValue.
for (uint32_t i = 0; i < val->Length(); ++i) {
v8::TryCatch try_catch(isolate);
v8::Local<v8::Value> child_v8;
v8::MaybeLocal<v8::Value> maybe_child =
val->Get(isolate->GetCurrentContext(), i);
if (try_catch.HasCaught() || !maybe_child.ToLocal(&child_v8)) {
LOG(ERROR) << "Getter for index " << i << " threw an exception.";
child_v8 = v8::Null(isolate);
}
if (!val->HasRealIndexedProperty(isolate->GetCurrentContext(), i)
.FromMaybe(false)) {
result->Append(base::Value());
continue;
}
std::unique_ptr<base::Value> child =
FromV8ValueImpl(state, child_v8, isolate);
if (child) {
result->Append(base::Value::FromUniquePtrValue(std::move(child)));
} else {
// JSON.stringify puts null in places where values don't serialize, for
// example undefined and functions. Emulate that behavior.
result->Append(base::Value());
}
}
return std::move(result);
}
std::unique_ptr<base::Value> V8ValueConverter::FromNodeBuffer(
v8::Local<v8::Value> value,
FromV8ValueState* state,
v8::Isolate* isolate) const {
std::vector<char> buffer(
node::Buffer::Data(value),
node::Buffer::Data(value) + node::Buffer::Length(value));
return std::make_unique<base::Value>(std::move(buffer));
}
std::unique_ptr<base::Value> V8ValueConverter::FromV8Object(
v8::Local<v8::Object> val,
FromV8ValueState* state,
v8::Isolate* isolate) const {
ScopedUniquenessGuard uniqueness_guard(state, val);
if (!uniqueness_guard.is_valid())
return std::make_unique<base::Value>();
std::unique_ptr<v8::Context::Scope> scope;
// If val was created in a different context than our current one, change to
// that context, but change back after val is converted.
if (!val->GetCreationContextChecked().IsEmpty() &&
val->GetCreationContextChecked() != isolate->GetCurrentContext())
scope =
std::make_unique<v8::Context::Scope>(val->GetCreationContextChecked());
auto result = std::make_unique<base::DictionaryValue>();
v8::Local<v8::Array> property_names;
if (!val->GetOwnPropertyNames(isolate->GetCurrentContext())
.ToLocal(&property_names)) {
return std::move(result);
}
for (uint32_t i = 0; i < property_names->Length(); ++i) {
v8::Local<v8::Value> key =
property_names->Get(isolate->GetCurrentContext(), i).ToLocalChecked();
// Extend this test to cover more types as necessary and if sensible.
if (!key->IsString() && !key->IsNumber()) {
NOTREACHED() << "Key \"" << *v8::String::Utf8Value(isolate, key)
<< "\" "
"is neither a string nor a number";
continue;
}
v8::String::Utf8Value name_utf8(isolate, key);
v8::TryCatch try_catch(isolate);
v8::Local<v8::Value> child_v8;
v8::MaybeLocal<v8::Value> maybe_child =
val->Get(isolate->GetCurrentContext(), key);
if (try_catch.HasCaught() || !maybe_child.ToLocal(&child_v8)) {
LOG(ERROR) << "Getter for property " << *name_utf8
<< " threw an exception.";
child_v8 = v8::Null(isolate);
}
std::unique_ptr<base::Value> child =
FromV8ValueImpl(state, child_v8, isolate);
if (!child)
// JSON.stringify skips properties whose values don't serialize, for
// example undefined and functions. Emulate that behavior.
continue;
// Strip null if asked (and since undefined is turned into null, undefined
// too). The use case for supporting this is JSON-schema support,
// specifically for extensions, where "optional" JSON properties may be
// represented as null, yet due to buggy legacy code elsewhere isn't
// treated as such (potentially causing crashes). For example, the
// "tabs.create" function takes an object as its first argument with an
// optional "windowId" property.
//
// Given just
//
// tabs.create({})
//
// this will work as expected on code that only checks for the existence of
// a "windowId" property (such as that legacy code). However given
//
// tabs.create({windowId: null})
//
// there *is* a "windowId" property, but since it should be an int, code
// on the browser which doesn't additionally check for null will fail.
// We can avoid all bugs related to this by stripping null.
if (strip_null_from_objects_ && child->is_none())
continue;
result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
std::move(child));
}
return std::move(result);
}
} // namespace electron

78
shell/common/v8_value_converter.h
View file

@ -1,78 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef ELECTRON_SHELL_COMMON_V8_VALUE_CONVERTER_H_
#define ELECTRON_SHELL_COMMON_V8_VALUE_CONVERTER_H_
#include <memory>
#include "base/compiler_specific.h"
#include "v8/include/v8.h"
namespace base {
class DictionaryValue;
class ListValue;
class Value;
} // namespace base
namespace electron {
class V8ValueConverter {
public:
V8ValueConverter();
// disable copy
V8ValueConverter(const V8ValueConverter&) = delete;
V8ValueConverter& operator=(const V8ValueConverter&) = delete;
void SetRegExpAllowed(bool val);
void SetFunctionAllowed(bool val);
void SetStripNullFromObjects(bool val);
v8::Local<v8::Value> ToV8Value(const base::Value* value,
v8::Local<v8::Context> context) const;
std::unique_ptr<base::Value> FromV8Value(
v8::Local<v8::Value> value,
v8::Local<v8::Context> context) const;
private:
class FromV8ValueState;
class ScopedUniquenessGuard;
v8::Local<v8::Value> ToV8ValueImpl(v8::Isolate* isolate,
const base::Value* value) const;
v8::Local<v8::Value> ToV8Array(v8::Isolate* isolate,
const base::ListValue* list) const;
v8::Local<v8::Value> ToV8Object(
v8::Isolate* isolate,
const base::DictionaryValue* dictionary) const;
v8::Local<v8::Value> ToArrayBuffer(v8::Isolate* isolate,
const base::Value* value) const;
std::unique_ptr<base::Value> FromV8ValueImpl(FromV8ValueState* state,
v8::Local<v8::Value> value,
v8::Isolate* isolate) const;
std::unique_ptr<base::Value> FromV8Array(v8::Local<v8::Array> array,
FromV8ValueState* state,
v8::Isolate* isolate) const;
std::unique_ptr<base::Value> FromNodeBuffer(v8::Local<v8::Value> value,
FromV8ValueState* state,
v8::Isolate* isolate) const;
std::unique_ptr<base::Value> FromV8Object(v8::Local<v8::Object> object,
FromV8ValueState* state,
v8::Isolate* isolate) const;
// If true, we will convert RegExp JavaScript objects to string.
bool reg_exp_allowed_ = false;
// If true, we will convert Function JavaScript objects to dictionaries.
bool function_allowed_ = false;
// If true, undefined and null values are ignored when converting v8 objects
// into Values.
bool strip_null_from_objects_ = false;
};
} // namespace electron
#endif // ELECTRON_SHELL_COMMON_V8_VALUE_CONVERTER_H_

1
spec-main/api-system-preferences-spec.ts
View file

@ -46,7 +46,6 @@ describe('systemPreferences module', () => {
const badDefaults = [
1,
null,
new Date(),
{ one: null }
];