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

chore: bump chromium to 121.0.6116.0 (main) (#40490)

Browse source 
* chore: bump chromium in DEPS to 121.0.6116.0

* chore: update patches

* Update webIDL to support close event.

Refs 4970653

* Remove uses of implicit conversion of ScopedTypeRef

Refs https://bugs.chromium.org/p/chromium/issues/detail?id=1495439

* Add GlobalRenderFrameHostToken

Refs 5001743

* [DevTools] Console Insights: move from build flag to Feature API

Refs 5002232

* [Extensions] Use script serialization in scripting API

Refs 4968680
Refs 4998265

* [api] Remove AllCan Read/Write

5006387

* chore: update libcxx files

* chore: address nan compilation error

* spec: use nan dependency from third_party

It is easier to get fixes for spec modules depending on nan

* ci: publish nan artifact for woa

* fix: bad patch update

* chore: update nan resolution

* Revert "chore: update nan resolution"

This reverts commit 786cdb858c9fc8a038a8f3e16068ee5b4a050137.

---------

Co-authored-by: electron-roller[bot] <84116207+electron-roller[bot]@users.noreply.github.com>
Co-authored-by: deepak1556 <hop2deep@gmail.com>
This commit is contained in:
electron-roller[bot] 2023-11-14 13:21:32 -08:00 • committed by GitHub
parent b639fa4626
commit 0e4e9dc98c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
69 changed files with 538 additions and 437 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -435,7 +435,7 @@ v8::Local<v8::Promise> SystemPreferences::PromptTouchID(
__block gin_helper::Promise<void> p = std::move(promise);
[context
evaluateAccessControl:access_control
evaluateAccessControl:access_control.get()
operation:LAAccessControlOperationUseKeySign
localizedReason:[NSString stringWithUTF8String:reason.c_str()]
reply:^(BOOL success, NSError* error) {

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

@ -1868,8 +1868,9 @@ bool WebContents::EmitNavigationEvent(
content::RenderFrameHost* initiator_frame_host =
navigation_handle->GetInitiatorFrameToken().has_value()
? content::RenderFrameHost::FromFrameToken(
navigation_handle->GetInitiatorProcessId(),
navigation_handle->GetInitiatorFrameToken().value())
content::GlobalRenderFrameHostToken(
navigation_handle->GetInitiatorProcessId(),
navigation_handle->GetInitiatorFrameToken().value()))
: nullptr;
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();

6
shell/browser/browser_mac.mm
View file

@ -84,7 +84,7 @@ bool CheckLoginItemStatus(bool* is_hidden) {
return false;
if (is_hidden)
*is_hidden = base::mac::IsHiddenLoginItem(item);
*is_hidden = base::mac::IsHiddenLoginItem(item.get());
return true;
}
@ -252,8 +252,8 @@ bool Browser::IsDefaultProtocolClient(const std::string& protocol,
// Ensure the comparison is case-insensitive
// as LS does not persist the case of the bundle id.
NSComparisonResult result =
[base::apple::CFToNSPtrCast(bundleId) caseInsensitiveCompare:identifier];
NSComparisonResult result = [base::apple::CFToNSPtrCast(bundleId.get())
caseInsensitiveCompare:identifier];
return result == NSOrderedSame;
}

5
shell/browser/electron_browser_client.cc
View file

@ -1413,8 +1413,9 @@ void ElectronBrowserClient::OverrideURLLoaderFactoryParams(
if (factory_params->top_frame_id) {
// Bypass CORB and CORS when web security is disabled.
auto* rfh = content::RenderFrameHost::FromFrameToken(
factory_params->process_id,
blink::LocalFrameToken(factory_params->top_frame_id.value()));
content::GlobalRenderFrameHostToken(
factory_params->process_id,
blink::LocalFrameToken(factory_params->top_frame_id.value())));
auto* web_contents = content::WebContents::FromRenderFrameHost(rfh);
auto* prefs = WebContentsPreferences::From(web_contents);
if (prefs && !prefs->IsWebSecurityEnabled()) {

226
shell/browser/extensions/api/scripting/scripting_api.cc
View file

@ -29,6 +29,8 @@
#include "extensions/browser/script_executor.h"
#include "extensions/browser/user_script_manager.h"
#include "extensions/common/api/extension_types.h"
#include "extensions/common/api/scripts_internal.h"
#include "extensions/common/api/scripts_internal/script_serialization.h"
#include "extensions/common/error_utils.h"
#include "extensions/common/extension.h"
#include "extensions/common/manifest_constants.h"
@ -91,21 +93,6 @@ mojom::ExecutionWorld ConvertExecutionWorld(
return execution_world;
}
api::scripting::ExecutionWorld ConvertExecutionWorldForAPI(
mojom::ExecutionWorld world) {
switch (world) {
case mojom::ExecutionWorld::kIsolated:
return api::scripting::ExecutionWorld::kIsolated;
case mojom::ExecutionWorld::kMain:
return api::scripting::ExecutionWorld::kMain;
case mojom::ExecutionWorld::kUserScript:
NOTREACHED() << "UserScript worlds are not supported in this API.";
}
NOTREACHED();
return api::scripting::ExecutionWorld::kIsolated;
}
std::string InjectionKeyForCode(const mojom::HostID& host_id,
const std::string& code) {
return ScriptExecutor::GenerateInjectionKey(host_id, /*script_url=*/GURL(),
@ -454,106 +441,133 @@ bool CanAccessTarget(const PermissionsData& permissions,
return true;
}
api::scripts_internal::SerializedUserScript
ConvertRegisteredContentScriptToSerializedUserScript(
api::scripting::RegisteredContentScript content_script) {
auto convert_execution_world = [](api::scripting::ExecutionWorld world) {
switch (world) {
case api::scripting::ExecutionWorld::kNone:
case api::scripting::ExecutionWorld::kIsolated:
return api::extension_types::ExecutionWorld::kIsolated;
case api::scripting::ExecutionWorld::kMain:
return api::extension_types::ExecutionWorld::kMain;
}
};
api::scripts_internal::SerializedUserScript serialized_script;
serialized_script.source =
api::scripts_internal::Source::kDynamicContentScript;
// Note: IDs have already been prefixed appropriately.
serialized_script.id = std::move(content_script.id);
// Note: `matches` are guaranteed to be non-null.
serialized_script.matches = std::move(*content_script.matches);
serialized_script.exclude_matches = std::move(content_script.exclude_matches);
if (content_script.css) {
serialized_script.css = script_serialization::GetSourcesFromFileNames(
std::move(*content_script.css));
}
if (content_script.js) {
serialized_script.js = script_serialization::GetSourcesFromFileNames(
std::move(*content_script.js));
}
serialized_script.all_frames = content_script.all_frames;
serialized_script.match_origin_as_fallback =
content_script.match_origin_as_fallback;
serialized_script.run_at = content_script.run_at;
serialized_script.world = convert_execution_world(content_script.world);
return serialized_script;
}
std::unique_ptr<UserScript> ParseUserScript(
content::BrowserContext* browser_context,
const Extension& extension,
const api::scripting::RegisteredContentScript& content_script,
int definition_index,
int valid_schemes,
api::scripting::RegisteredContentScript content_script,
std::u16string* error) {
auto result = std::make_unique<UserScript>();
result->set_id(content_script.id);
result->set_host_id(
mojom::HostID(mojom::HostID::HostType::kExtensions, extension.id()));
api::scripts_internal::SerializedUserScript serialized_script =
ConvertRegisteredContentScriptToSerializedUserScript(
std::move(content_script));
if (content_script.run_at != api::extension_types::RunAt::kNone) {
result->set_run_location(ConvertRunLocation(content_script.run_at));
std::unique_ptr<UserScript> user_script =
script_serialization::ParseSerializedUserScript(serialized_script,
extension, error);
if (!user_script) {
return nullptr; // Parsing failed.
}
if (content_script.all_frames) {
result->set_match_all_frames(*content_script.all_frames);
}
DCHECK(content_script.matches);
if (!script_parsing::ParseMatchPatterns(
*content_script.matches,
base::OptionalToPtr(content_script.exclude_matches),
extension.creation_flags(), scripting::kScriptsCanExecuteEverywhere,
valid_schemes, scripting::kAllUrlsIncludesChromeUrls,
/*definition_index=*/absl::nullopt, result.get(), error,
/*wants_file_access=*/nullptr)) {
// Post conversion validation and values.
// TODO(https://crbug.com/1494155): See which of these can be moved into
// script_serialization::ParseSerializedUserScript().
if (!script_parsing::ValidateMatchOriginAsFallback(
user_script->match_origin_as_fallback(), user_script->url_patterns(),
error)) {
return nullptr;
}
if (content_script.match_origin_as_fallback.value_or(false)) {
if (!script_parsing::ValidateMatchOriginAsFallback(
MatchOriginAsFallbackBehavior::kAlways, result->url_patterns(),
error)) {
return nullptr;
}
// Default value for MatchOriginAsFallbackBehavior is `kNever`, so this only
// needs to be set if `content_script.match_origin_as_fallback` is true.
result->set_match_origin_as_fallback(
MatchOriginAsFallbackBehavior::kAlways);
}
if (!script_parsing::ParseFileSources(
&extension, base::OptionalToPtr(content_script.js),
base::OptionalToPtr(content_script.css), definition_index,
result.get(), error)) {
return nullptr;
}
result->set_incognito_enabled(
user_script->set_incognito_enabled(
util::IsIncognitoEnabled(extension.id(), browser_context));
result->set_execution_world(ConvertExecutionWorld(content_script.world));
return result;
return user_script;
}
// Converts a UserScript object to a api::scripting::RegisteredContentScript
// object, used for getRegisteredContentScripts.
api::scripting::RegisteredContentScript CreateRegisteredContentScriptInfo(
const UserScript& script) {
api::scripting::RegisteredContentScript script_info;
CHECK_EQ(UserScript::Source::kDynamicContentScript, script.GetSource());
script_info.id = script.id();
// To convert a `UserScript`, we first go through our script_internal
// serialization; this allows us to do simple conversions and avoid any
// complex logic.
api::scripts_internal::SerializedUserScript serialized_script =
script_serialization::SerializeUserScript(script);
script_info.matches.emplace();
script_info.matches->reserve(script.url_patterns().size());
for (const URLPattern& pattern : script.url_patterns())
script_info.matches->push_back(pattern.GetAsString());
auto convert_serialized_script_sources =
[](std::vector<api::scripts_internal::ScriptSource> sources) {
std::vector<std::string> converted;
converted.reserve(sources.size());
for (auto& source : sources) {
CHECK(source.file)
<< "Content scripts don't allow arbtirary code strings";
converted.push_back(std::move(*source.file));
}
return converted;
};
if (!script.exclude_url_patterns().is_empty()) {
script_info.exclude_matches.emplace();
script_info.exclude_matches->reserve(script.exclude_url_patterns().size());
for (const URLPattern& pattern : script.exclude_url_patterns())
script_info.exclude_matches->push_back(pattern.GetAsString());
auto convert_execution_world =
[](api::extension_types::ExecutionWorld world) {
switch (world) {
case api::extension_types::ExecutionWorld::kNone:
NOTREACHED_NORETURN()
<< "Execution world should always be present in serialization.";
case api::extension_types::ExecutionWorld::kIsolated:
return api::scripting::ExecutionWorld::kIsolated;
case api::extension_types::ExecutionWorld::kUserScript:
NOTREACHED_NORETURN()
<< "ISOLATED worlds are not supported in this API.";
case api::extension_types::ExecutionWorld::kMain:
return api::scripting::ExecutionWorld::kMain;
}
};
api::scripting::RegisteredContentScript content_script;
content_script.id = std::move(serialized_script.id);
content_script.matches = std::move(serialized_script.matches);
content_script.exclude_matches = std::move(serialized_script.exclude_matches);
if (serialized_script.css) {
content_script.css =
convert_serialized_script_sources(std::move(*serialized_script.css));
}
// File paths may be normalized in the returned object and can differ slightly
// compared to what was originally passed into registerContentScripts.
if (!script.js_scripts().empty()) {
script_info.js.emplace();
script_info.js->reserve(script.js_scripts().size());
for (const auto& js_script : script.js_scripts())
script_info.js->push_back(js_script->relative_path().AsUTF8Unsafe());
if (serialized_script.js) {
content_script.js =
convert_serialized_script_sources(std::move(*serialized_script.js));
}
content_script.all_frames = serialized_script.all_frames;
content_script.match_origin_as_fallback =
serialized_script.match_origin_as_fallback;
content_script.run_at = serialized_script.run_at;
content_script.world = convert_execution_world(serialized_script.world);
if (!script.css_scripts().empty()) {
script_info.css.emplace();
script_info.css->reserve(script.css_scripts().size());
for (const auto& css_script : script.css_scripts())
script_info.css->push_back(css_script->relative_path().AsUTF8Unsafe());
}
script_info.all_frames = script.match_all_frames();
script_info.match_origin_as_fallback = script.match_origin_as_fallback() ==
MatchOriginAsFallbackBehavior::kAlways;
script_info.run_at = ConvertRunLocationForAPI(script.run_location());
script_info.world = ConvertExecutionWorldForAPI(script.execution_world());
return script_info;
return content_script;
}
} // namespace
@ -962,9 +976,6 @@ ExtensionFunction::ResponseAction ScriptingUpdateContentScriptsFunction::Run() {
std::u16string parse_error;
auto parsed_scripts = std::make_unique<UserScriptList>();
const int valid_schemes = UserScript::ValidUserScriptSchemes(
scripting::kScriptsCanExecuteEverywhere);
std::set<std::string> updated_script_ids_to_persist;
std::set<std::string> persistent_script_ids =
loader->GetPersistentDynamicScriptIDs();
@ -1003,8 +1014,8 @@ ExtensionFunction::ResponseAction ScriptingUpdateContentScriptsFunction::Run() {
// Parse/Create user script.
std::unique_ptr<UserScript> user_script =
ParseUserScript(browser_context(), *extension(), updated_script, i,
valid_schemes, &parse_error);
ParseUserScript(browser_context(), *extension(),
std::move(updated_script), &parse_error);
if (!user_script)
return RespondNow(Error(base::UTF16ToASCII(parse_error)));
@ -1237,32 +1248,33 @@ ScriptingRegisterContentScriptsFunction::Run() {
std::u16string parse_error;
auto parsed_scripts = std::make_unique<UserScriptList>();
std::set<std::string> persistent_script_ids;
const int valid_schemes = UserScript::ValidUserScriptSchemes(
scripting::kScriptsCanExecuteEverywhere);
parsed_scripts->reserve(scripts.size());
for (size_t i = 0; i < scripts.size(); ++i) {
if (!scripts[i].matches) {
for (auto& script : scripts) {
if (!script.matches) {
std::string error_script_id =
UserScript::TrimPrefixFromScriptID(scripts[i].id);
UserScript::TrimPrefixFromScriptID(script.id);
return RespondNow(
Error(base::StringPrintf("Script with ID '%s' must specify 'matches'",
error_script_id.c_str())));
}
std::unique_ptr<UserScript> user_script =
ParseUserScript(browser_context(), *extension(), scripts[i], i,
valid_schemes, &parse_error);
// Scripts will persist across sessions by default.
bool persist_across_sessions =
script.persist_across_sessions.value_or(true);
std::unique_ptr<UserScript> user_script = ParseUserScript(
browser_context(), *extension(), std::move(script), &parse_error);
if (!user_script)
return RespondNow(Error(base::UTF16ToASCII(parse_error)));
// Scripts will persist across sessions by default.
if (!scripts[i].persist_across_sessions ||
*scripts[i].persist_across_sessions) {
if (persist_across_sessions) {
persistent_script_ids.insert(user_script->id());
}
parsed_scripts->push_back(std::move(user_script));
}
// The contents of `scripts` have all been std::move()'d.
scripts.clear();
// Add new script IDs now in case another call with the same script IDs is
// made immediately following this one.

2
shell/browser/native_browser_view_mac.mm
View file

@ -84,7 +84,7 @@ void NativeBrowserViewMac::SetBackgroundColor(SkColor color) {
return;
auto* view = iwc_view->GetNativeView().GetNativeNSView();
view.wantsLayer = YES;
view.layer.backgroundColor = skia::CGColorCreateFromSkColor(color);
view.layer.backgroundColor = skia::CGColorCreateFromSkColor(color).get();
}
// static

2
shell/browser/native_window_mac.mm
View file

@ -1182,7 +1182,7 @@ bool NativeWindowMac::IsKiosk() {
void NativeWindowMac::SetBackgroundColor(SkColor color) {
base::apple::ScopedCFTypeRef<CGColorRef> cgcolor(
skia::CGColorCreateFromSkColor(color));
[[[window_ contentView] layer] setBackgroundColor:cgcolor];
[[[window_ contentView] layer] setBackgroundColor:cgcolor.get()];
}
SkColor NativeWindowMac::GetBackgroundColor() {

8
shell/browser/osr/osr_host_display_client_mac.mm
View file

@ -12,11 +12,13 @@ void OffScreenHostDisplayClient::OnDisplayReceivedCALayerParams(
const gfx::CALayerParams& ca_layer_params) {
if (!ca_layer_params.is_empty) {
base::apple::ScopedCFTypeRef<IOSurfaceRef> io_surface(
IOSurfaceLookupFromMachPort(ca_layer_params.io_surface_mach_port));
IOSurfaceLookupFromMachPort(
ca_layer_params.io_surface_mach_port.get()));
gfx::Size pixel_size_ = ca_layer_params.pixel_size;
void* pixels = static_cast<void*>(IOSurfaceGetBaseAddress(io_surface));
size_t stride = IOSurfaceGetBytesPerRow(io_surface);
void* pixels =
static_cast<void*>(IOSurfaceGetBaseAddress(io_surface.get()));
size_t stride = IOSurfaceGetBytesPerRow(io_surface.get());
struct IOSurfacePinner {
base::apple::ScopedCFTypeRef<IOSurfaceRef> io_surface;

4
shell/browser/ui/certificate_trust_mac.mm
View file

@ -92,7 +92,7 @@ v8::Local<v8::Promise> ShowCertificateTrust(
auto cert_chain =
net::x509_util::CreateSecCertificateArrayForX509Certificate(cert.get());
SecTrustRef trust = nullptr;
SecTrustCreateWithCertificates(cert_chain, sec_policy, &trust);
SecTrustCreateWithCertificates(cert_chain.get(), sec_policy, &trust);
NSWindow* window = parent_window
? parent_window->GetNativeWindow().GetNativeNSWindow()
@ -104,7 +104,7 @@ v8::Local<v8::Promise> ShowCertificateTrust(
panel:panel
cert:cert
trust:trust
certChain:cert_chain
certChain:cert_chain.release()
secPolicy:sec_policy];
[panel beginSheetForWindow:window
modalDelegate:delegate

2
shell/browser/ui/inspectable_web_contents.h
View file

@ -173,6 +173,8 @@ class InspectableWebContents
const std::string& trigger) override {}
void CanShowSurvey(DispatchCallback callback,
const std::string& trigger) override {}
void DoAidaConversation(DispatchCallback callback,
const std::string& request) override {}
// content::DevToolsFrontendHostDelegate:
void HandleMessageFromDevToolsFrontend(base::Value::Dict message);