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

refactor: use constexpr lookup tables in gin helper (#38818)

Browse source 
* feat: add gin_helper::FromV8WithLookup()

feat: add gin_helper::FromV8WithLowerLookup()

* refactor: use constexpr lookup table in gin Converters
This commit is contained in:
Charles Kerr 2023-06-19 03:33:09 -05:00 • committed by GitHub
parent 41ab5f327f
commit 97132ece33
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 255 additions and 400 deletions
Download patch file Download diff file Expand all files Collapse all files

110
shell/browser/api/electron_api_app.cc
View file

@ -141,40 +141,25 @@ struct Converter<JumpListItem::Type> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
JumpListItem::Type* out) {
std::string item_type;
if (!ConvertFromV8(isolate, val, &item_type))
return false;
if (item_type == "task")
*out = JumpListItem::Type::kTask;
else if (item_type == "separator")
*out = JumpListItem::Type::kSeparator;
else if (item_type == "file")
*out = JumpListItem::Type::kFile;
else
return false;
return true;
return FromV8WithLookup(isolate, val, Lookup, out);
}
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
JumpListItem::Type val) {
std::string item_type;
switch (val) {
case JumpListItem::Type::kTask:
item_type = "task";
break;
for (const auto& [name, item_val] : Lookup)
if (item_val == val)
return gin::ConvertToV8(isolate, name);
case JumpListItem::Type::kSeparator:
item_type = "separator";
break;
case JumpListItem::Type::kFile:
item_type = "file";
break;
}
return gin::ConvertToV8(isolate, item_type);
return gin::ConvertToV8(isolate, "");
}
private:
static constexpr auto Lookup =
base::MakeFixedFlatMapSorted<base::StringPiece, JumpListItem::Type>({
{"file", JumpListItem::Type::kFile},
{"separator", JumpListItem::Type::kSeparator},
{"task", JumpListItem::Type::kTask},
});
};
template <>
@ -247,46 +232,26 @@ struct Converter<JumpListCategory::Type> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
JumpListCategory::Type* out) {
std::string category_type;
if (!ConvertFromV8(isolate, val, &category_type))
return false;
if (category_type == "tasks")
*out = JumpListCategory::Type::kTasks;
else if (category_type == "frequent")
*out = JumpListCategory::Type::kFrequent;
else if (category_type == "recent")
*out = JumpListCategory::Type::kRecent;
else if (category_type == "custom")
*out = JumpListCategory::Type::kCustom;
else
return false;
return true;
return FromV8WithLookup(isolate, val, Lookup, out);
}
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
JumpListCategory::Type val) {
std::string category_type;
switch (val) {
case JumpListCategory::Type::kTasks:
category_type = "tasks";
break;
for (const auto& [name, type_val] : Lookup)
if (type_val == val)
return gin::ConvertToV8(isolate, name);
case JumpListCategory::Type::kFrequent:
category_type = "frequent";
break;
case JumpListCategory::Type::kRecent:
category_type = "recent";
break;
case JumpListCategory::Type::kCustom:
category_type = "custom";
break;
}
return gin::ConvertToV8(isolate, category_type);
return gin::ConvertToV8(isolate, "");
}
private:
static constexpr auto Lookup =
base::MakeFixedFlatMapSorted<base::StringPiece, JumpListCategory::Type>({
{"custom", JumpListCategory::Type::kCustom},
{"frequent", JumpListCategory::Type::kFrequent},
{"recent", JumpListCategory::Type::kRecent},
{"tasks", JumpListCategory::Type::kTasks},
});
};
template <>
@ -440,20 +405,13 @@ struct Converter<net::SecureDnsMode> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
net::SecureDnsMode* out) {
std::string s;
if (!ConvertFromV8(isolate, val, &s))
return false;
if (s == "off") {
*out = net::SecureDnsMode::kOff;
return true;
} else if (s == "automatic") {
*out = net::SecureDnsMode::kAutomatic;
return true;
} else if (s == "secure") {
*out = net::SecureDnsMode::kSecure;
return true;
}
return false;
static constexpr auto Lookup =
base::MakeFixedFlatMapSorted<base::StringPiece, net::SecureDnsMode>({
{"automatic", net::SecureDnsMode::kAutomatic},
{"off", net::SecureDnsMode::kOff},
{"secure", net::SecureDnsMode::kSecure},
});
return FromV8WithLookup(isolate, val, Lookup, out);
}
};
} // namespace gin

104
shell/browser/api/electron_api_url_loader.cc
View file

@ -62,20 +62,16 @@ struct Converter<network::mojom::CredentialsMode> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
network::mojom::CredentialsMode* out) {
std::string mode;
if (!ConvertFromV8(isolate, val, &mode))
return false;
if (mode == "omit")
*out = network::mojom::CredentialsMode::kOmit;
else if (mode == "include")
*out = network::mojom::CredentialsMode::kInclude;
else if (mode == "same-origin")
// Note: This only makes sense if the request specifies the "origin"
// option.
*out = network::mojom::CredentialsMode::kSameOrigin;
else
return false;
return true;
using Val = network::mojom::CredentialsMode;
static constexpr auto Lookup =
base::MakeFixedFlatMapSorted<base::StringPiece, Val>({
{"include", Val::kInclude},
{"omit", Val::kOmit},
// Note: This only makes sense if the request
// specifies the "origin" option.
{"same-origin", Val::kSameOrigin},
});
return FromV8WithLookup(isolate, val, Lookup, out);
}
};
@ -84,25 +80,17 @@ struct Converter<blink::mojom::FetchCacheMode> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
blink::mojom::FetchCacheMode* out) {
std::string cache;
if (!ConvertFromV8(isolate, val, &cache))
return false;
if (cache == "default") {
*out = blink::mojom::FetchCacheMode::kDefault;
} else if (cache == "no-store") {
*out = blink::mojom::FetchCacheMode::kNoStore;
} else if (cache == "reload") {
*out = blink::mojom::FetchCacheMode::kBypassCache;
} else if (cache == "no-cache") {
*out = blink::mojom::FetchCacheMode::kValidateCache;
} else if (cache == "force-cache") {
*out = blink::mojom::FetchCacheMode::kForceCache;
} else if (cache == "only-if-cached") {
*out = blink::mojom::FetchCacheMode::kOnlyIfCached;
} else {
return false;
}
return true;
using Val = blink::mojom::FetchCacheMode;
static constexpr auto Lookup =
base::MakeFixedFlatMapSorted<base::StringPiece, Val>({
{"default", Val::kDefault},
{"force-cache", Val::kForceCache},
{"no-cache", Val::kValidateCache},
{"no-store", Val::kNoStore},
{"only-if-cached", Val::kOnlyIfCached},
{"reload", Val::kBypassCache},
});
return FromV8WithLookup(isolate, val, Lookup, out);
}
};
@ -111,42 +99,24 @@ struct Converter<net::ReferrerPolicy> {
static bool FromV8(v8::Isolate* isolate,
v8::Local<v8::Value> val,
net::ReferrerPolicy* out) {
std::string referrer_policy;
if (!ConvertFromV8(isolate, val, &referrer_policy))
return false;
if (base::CompareCaseInsensitiveASCII(referrer_policy, "no-referrer") ==
0) {
*out = net::ReferrerPolicy::NO_REFERRER;
} else if (base::CompareCaseInsensitiveASCII(
referrer_policy, "no-referrer-when-downgrade") == 0) {
*out = net::ReferrerPolicy::CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
} else if (base::CompareCaseInsensitiveASCII(referrer_policy, "origin") ==
0) {
*out = net::ReferrerPolicy::ORIGIN;
} else if (base::CompareCaseInsensitiveASCII(
referrer_policy, "origin-when-cross-origin") == 0) {
*out = net::ReferrerPolicy::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN;
} else if (base::CompareCaseInsensitiveASCII(referrer_policy,
"unsafe-url") == 0) {
*out = net::ReferrerPolicy::NEVER_CLEAR;
} else if (base::CompareCaseInsensitiveASCII(referrer_policy,
"same-origin") == 0) {
*out = net::ReferrerPolicy::CLEAR_ON_TRANSITION_CROSS_ORIGIN;
} else if (base::CompareCaseInsensitiveASCII(referrer_policy,
"strict-origin") == 0) {
*out = net::ReferrerPolicy::
ORIGIN_CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE;
} else if (referrer_policy == "" ||
base::CompareCaseInsensitiveASCII(
referrer_policy, "strict-origin-when-cross-origin") == 0) {
*out = net::ReferrerPolicy::REDUCE_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN;
} else {
return false;
}
return true;
using Val = net::ReferrerPolicy;
// clang-format off
static constexpr auto Lookup =
base::MakeFixedFlatMapSorted<base::StringPiece, Val>({
{"", Val::REDUCE_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN},
{"no-referrer", Val::NO_REFERRER},
{"no-referrer-when-downgrade", Val::CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE},
{"origin", Val::ORIGIN},
{"origin-when-cross-origin", Val::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN},
{"same-origin", Val::CLEAR_ON_TRANSITION_CROSS_ORIGIN},
{"strict-origin", Val:: ORIGIN_CLEAR_ON_TRANSITION_FROM_SECURE_TO_INSECURE},
{"strict-origin-when-cross-origin", Val::REDUCE_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN},
{"unsafe-url", Val::NEVER_CLEAR},
});
// clang-format on
return FromV8WithLowerLookup(isolate, val, Lookup, out);
}
};
} // namespace gin
namespace electron::api {

98
shell/browser/api/electron_api_web_request.cc
View file

@ -9,6 +9,7 @@
#include <utility>
#include "base/containers/contains.h"
#include "base/containers/fixed_flat_map.h"
#include "base/memory/raw_ptr.h"
#include "base/stl_util.h"
#include "base/task/sequenced_task_runner.h"
@ -31,54 +32,34 @@
#include "shell/common/gin_converters/value_converter.h"
#include "shell/common/gin_helper/dictionary.h"
static constexpr auto ResourceTypes =
base::MakeFixedFlatMapSorted<base::StringPiece,
extensions::WebRequestResourceType>({
{"cspReport", extensions::WebRequestResourceType::CSP_REPORT},
{"font", extensions::WebRequestResourceType::FONT},
{"image", extensions::WebRequestResourceType::IMAGE},
{"mainFrame", extensions::WebRequestResourceType::MAIN_FRAME},
{"media", extensions::WebRequestResourceType::MEDIA},
{"object", extensions::WebRequestResourceType::OBJECT},
{"ping", extensions::WebRequestResourceType::PING},
{"script", extensions::WebRequestResourceType::SCRIPT},
{"stylesheet", extensions::WebRequestResourceType::STYLESHEET},
{"subFrame", extensions::WebRequestResourceType::SUB_FRAME},
{"webSocket", extensions::WebRequestResourceType::WEB_SOCKET},
{"xhr", extensions::WebRequestResourceType::XHR},
});
namespace gin {
template <>
struct Converter<extensions::WebRequestResourceType> {
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
extensions::WebRequestResourceType type) {
const char* result;
switch (type) {
case extensions::WebRequestResourceType::MAIN_FRAME:
result = "mainFrame";
break;
case extensions::WebRequestResourceType::SUB_FRAME:
result = "subFrame";
break;
case extensions::WebRequestResourceType::STYLESHEET:
result = "stylesheet";
break;
case extensions::WebRequestResourceType::SCRIPT:
result = "script";
break;
case extensions::WebRequestResourceType::IMAGE:
result = "image";
break;
case extensions::WebRequestResourceType::FONT:
result = "font";
break;
case extensions::WebRequestResourceType::OBJECT:
result = "object";
break;
case extensions::WebRequestResourceType::XHR:
result = "xhr";
break;
case extensions::WebRequestResourceType::PING:
result = "ping";
break;
case extensions::WebRequestResourceType::CSP_REPORT:
result = "cspReport";
break;
case extensions::WebRequestResourceType::MEDIA:
result = "media";
break;
case extensions::WebRequestResourceType::WEB_SOCKET:
result = "webSocket";
break;
default:
result = "other";
}
return StringToV8(isolate, result);
for (const auto& [name, val] : ResourceTypes)
if (type == val)
return StringToV8(isolate, name);
return StringToV8(isolate, "other");
}
};
@ -96,34 +77,11 @@ struct UserData : public base::SupportsUserData::Data {
raw_ptr<WebRequest> data;
};
extensions::WebRequestResourceType ParseResourceType(const std::string& value) {
if (value == "mainFrame") {
return extensions::WebRequestResourceType::MAIN_FRAME;
} else if (value == "subFrame") {
return extensions::WebRequestResourceType::SUB_FRAME;
} else if (value == "stylesheet") {
return extensions::WebRequestResourceType::STYLESHEET;
} else if (value == "script") {
return extensions::WebRequestResourceType::SCRIPT;
} else if (value == "image") {
return extensions::WebRequestResourceType::IMAGE;
} else if (value == "font") {
return extensions::WebRequestResourceType::FONT;
} else if (value == "object") {
return extensions::WebRequestResourceType::OBJECT;
} else if (value == "xhr") {
return extensions::WebRequestResourceType::XHR;
} else if (value == "ping") {
return extensions::WebRequestResourceType::PING;
} else if (value == "cspReport") {
return extensions::WebRequestResourceType::CSP_REPORT;
} else if (value == "media") {
return extensions::WebRequestResourceType::MEDIA;
} else if (value == "webSocket") {
return extensions::WebRequestResourceType::WEB_SOCKET;
} else {
return extensions::WebRequestResourceType::OTHER;
}
extensions::WebRequestResourceType ParseResourceType(base::StringPiece value) {
if (const auto* iter = ResourceTypes.find(value); iter != ResourceTypes.end())
return iter->second;
return extensions::WebRequestResourceType::OTHER;
}
// Convert HttpResponseHeaders to V8.