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

chore: bump chromium to e836cbe709f3cd703f233de8eb6cc6ec99b72c9d (#27475)

Browse source 
Co-authored-by: deepak1556 <hop2deep@gmail.com>
Co-authored-by: Jeremy Rose <nornagon@nornagon.net>
This commit is contained in:
Shelley Vohr 2021-02-09 12:16:21 -08:00 • committed by GitHub
parent 44460e84c0
commit e46446e7e4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
93 changed files with 705 additions and 896 deletions
Download patch file Download diff file Expand all files Collapse all files

26
shell/browser/api/electron_api_global_shortcut.cc
View file

@ -9,7 +9,6 @@
#include "base/stl_util.h"
#include "base/strings/utf_string_conversions.h"
#include "chrome/common/extensions/command.h"
#include "gin/dictionary.h"
#include "gin/object_template_builder.h"
#include "shell/browser/api/electron_api_system_preferences.h"
@ -22,7 +21,6 @@
#include "base/mac/mac_util.h"
#endif
using extensions::Command;
using extensions::GlobalShortcutListener;
namespace {
@ -46,15 +44,6 @@ bool RegisteringMediaKeyForUntrustedClient(const ui::Accelerator& accelerator) {
}
return false;
}
bool MapHasMediaKeys(
const std::map<ui::Accelerator, base::Closure>& accelerator_map) {
auto media_key = std::find_if(
accelerator_map.begin(), accelerator_map.end(),
[](const auto& ac) { return Command::IsMediaKey(ac.first); });
return media_key != accelerator_map.end();
}
#endif
} // namespace
@ -112,12 +101,8 @@ bool GlobalShortcut::Register(const ui::Accelerator& accelerator,
return false;
}
#if defined(OS_MAC)
if (Command::IsMediaKey(accelerator)) {
if (RegisteringMediaKeyForUntrustedClient(accelerator))
return false;
GlobalShortcutListener::SetShouldUseInternalMediaKeyHandling(false);
}
if (RegisteringMediaKeyForUntrustedClient(accelerator))
return false;
#endif
if (!GlobalShortcutListener::GetInstance()->RegisterAccelerator(accelerator,
@ -138,13 +123,6 @@ void GlobalShortcut::Unregister(const ui::Accelerator& accelerator) {
if (accelerator_callback_map_.erase(accelerator) == 0)
return;
#if defined(OS_MAC)
if (Command::IsMediaKey(accelerator) &&
!MapHasMediaKeys(accelerator_callback_map_)) {
GlobalShortcutListener::SetShouldUseInternalMediaKeyHandling(true);
}
#endif
GlobalShortcutListener::GetInstance()->UnregisterAccelerator(accelerator,
this);
}

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

@ -136,8 +136,8 @@ v8::Local<v8::Promise> NetLog::StartLogging(base::FilePath log_path,
->GetNetworkContext();
network_context->CreateNetLogExporter(mojo::MakeRequest(&net_log_exporter_));
net_log_exporter_.set_connection_error_handler(
base::BindOnce(&NetLog::OnConnectionError, base::Unretained(this)));
net_log_exporter_.set_connection_error_handler(base::BindOnce(
&NetLog::OnConnectionError, weak_ptr_factory_.GetWeakPtr()));
base::PostTaskAndReplyWithResult(
file_task_runner_.get(), FROM_HERE,

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

@ -74,6 +74,7 @@
#include "mojo/public/cpp/system/platform_handle.h"
#include "ppapi/buildflags/buildflags.h"
#include "printing/buildflags/buildflags.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "shell/browser/api/electron_api_browser_window.h"
#include "shell/browser/api/electron_api_debugger.h"
#include "shell/browser/api/electron_api_session.h"
@ -1372,6 +1373,8 @@ void WebContents::RenderFrameCreated(
static_cast<content::RenderWidgetHostImpl*>(rwhv->GetRenderWidgetHost());
if (rwh_impl)
rwh_impl->disable_hidden_ = !background_throttling_;
WebFrameMain::RenderFrameCreated(render_frame_host);
}
void WebContents::RenderViewDeleted(content::RenderViewHost* render_view_host) {
@ -1577,11 +1580,19 @@ void WebContents::MessageTo(bool internal,
const std::string& channel,
blink::CloneableMessage arguments) {
TRACE_EVENT1("electron", "WebContents::MessageTo", "channel", channel);
auto* web_contents = FromID(web_contents_id);
auto* target_web_contents = FromID(web_contents_id);
if (web_contents) {
web_contents->SendIPCMessageWithSender(internal, channel,
std::move(arguments), ID());
if (target_web_contents) {
content::RenderFrameHost* frame = target_web_contents->MainFrame();
DCHECK(frame);
v8::HandleScope handle_scope(JavascriptEnvironment::GetIsolate());
gin::Handle<WebFrameMain> web_frame_main =
WebFrameMain::From(JavascriptEnvironment::GetIsolate(), frame);
int32_t sender_id = ID();
web_frame_main->GetRendererApi()->Message(internal, channel,
std::move(arguments), sender_id);
}
}
@ -1967,9 +1978,6 @@ void WebContents::LoadURL(const GURL& url,
// Calling LoadURLWithParams() can trigger JS which destroys |this|.
auto weak_this = GetWeakPtr();
// Required to make beforeunload handler work.
NotifyUserActivation();
params.transition_type = ui::PAGE_TRANSITION_TYPED;
params.should_clear_history_list = true;
params.override_user_agent = content::NavigationController::UA_OVERRIDE_TRUE;
@ -1984,6 +1992,9 @@ void WebContents::LoadURL(const GURL& url,
if (!weak_this)
return;
// Required to make beforeunload handler work.
NotifyUserActivation();
// Set the background color of RenderWidgetHostView.
// We have to call it right after LoadURL because the RenderViewHost is only
// created after loading a page.
@ -2674,30 +2685,6 @@ bool WebContents::IsFocused() const {
}
#endif
bool WebContents::SendIPCMessage(bool internal,
const std::string& channel,
v8::Local<v8::Value> args) {
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
blink::CloneableMessage message;
if (!gin::ConvertFromV8(isolate, args, &message)) {
isolate->ThrowException(v8::Exception::Error(
gin::StringToV8(isolate, "Failed to serialize arguments")));
return false;
}
return SendIPCMessageWithSender(internal, channel, std::move(message));
}
bool WebContents::SendIPCMessageWithSender(bool internal,
const std::string& channel,
blink::CloneableMessage args,
int32_t sender_id) {
auto* frame_host = web_contents()->GetMainFrame();
mojo::AssociatedRemote<mojom::ElectronRenderer> electron_renderer;
frame_host->GetRemoteAssociatedInterfaces()->GetInterface(&electron_renderer);
electron_renderer->Message(internal, channel, std::move(args), sender_id);
return true;
}
void WebContents::SendInputEvent(v8::Isolate* isolate,
v8::Local<v8::Value> input_event) {
content::RenderWidgetHostView* view =
@ -3111,12 +3098,10 @@ void WebContents::GrantOriginAccess(const GURL& url) {
}
void WebContents::NotifyUserActivation() {
auto* frame = web_contents()->GetMainFrame();
if (!frame)
return;
mojo::AssociatedRemote<mojom::ElectronRenderer> renderer;
frame->GetRemoteAssociatedInterfaces()->GetInterface(&renderer);
renderer->NotifyUserActivation();
content::RenderFrameHost* frame = web_contents()->GetMainFrame();
if (frame)
frame->NotifyUserActivation(
blink::mojom::UserActivationNotificationType::kInteraction);
}
v8::Local<v8::Promise> WebContents::TakeHeapSnapshot(
@ -3139,18 +3124,23 @@ v8::Local<v8::Promise> WebContents::TakeHeapSnapshot(
return handle;
}
if (!frame_host->IsRenderFrameCreated()) {
promise.RejectWithErrorMessage("takeHeapSnapshot failed");
return handle;
}
// This dance with `base::Owned` is to ensure that the interface stays alive
// until the callback is called. Otherwise it would be closed at the end of
// this function.
auto electron_renderer =
std::make_unique<mojo::AssociatedRemote<mojom::ElectronRenderer>>();
frame_host->GetRemoteAssociatedInterfaces()->GetInterface(
electron_renderer.get());
std::make_unique<mojo::Remote<mojom::ElectronRenderer>>();
frame_host->GetRemoteInterfaces()->GetInterface(
electron_renderer->BindNewPipeAndPassReceiver());
auto* raw_ptr = electron_renderer.get();
(*raw_ptr)->TakeHeapSnapshot(
mojo::WrapPlatformFile(base::ScopedPlatformFile(file.TakePlatformFile())),
base::BindOnce(
[](mojo::AssociatedRemote<mojom::ElectronRenderer>* ep,
[](mojo::Remote<mojom::ElectronRenderer>* ep,
gin_helper::Promise<void> promise, bool success) {
if (success) {
promise.Resolve();
@ -3606,7 +3596,6 @@ v8::Local<v8::ObjectTemplate> WebContents::FillObjectTemplate(
.SetMethod("stopFindInPage", &WebContents::StopFindInPage)
.SetMethod("focus", &WebContents::Focus)
.SetMethod("isFocused", &WebContents::IsFocused)
.SetMethod("_send", &WebContents::SendIPCMessage)
.SetMethod("sendInputEvent", &WebContents::SendInputEvent)
.SetMethod("beginFrameSubscription", &WebContents::BeginFrameSubscription)
.SetMethod("endFrameSubscription", &WebContents::EndFrameSubscription)

11
shell/browser/api/electron_api_web_contents.h
View file

@ -44,7 +44,6 @@
#if BUILDFLAG(ENABLE_PRINTING)
#include "chrome/browser/printing/print_view_manager_basic.h"
#include "components/printing/common/print_messages.h"
#include "shell/browser/printing/print_preview_message_handler.h"
#endif
@ -250,16 +249,6 @@ class WebContents : public gin::Wrappable<WebContents>,
void Focus();
bool IsFocused() const;
// Send messages to browser.
bool SendIPCMessage(bool internal,
const std::string& channel,
v8::Local<v8::Value> args);
bool SendIPCMessageWithSender(bool internal,
const std::string& channel,
blink::CloneableMessage args,
int32_t sender_id = 0);
// Send WebInputEvent to the page.
void SendInputEvent(v8::Isolate* isolate, v8::Local<v8::Value> input_event);

46
shell/browser/api/electron_api_web_frame_main.cc
View file

@ -15,6 +15,7 @@
#include "content/public/browser/render_frame_host.h"
#include "electron/shell/common/api/api.mojom.h"
#include "gin/object_template_builder.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "shell/browser/api/message_port.h"
#include "shell/browser/browser.h"
#include "shell/browser/javascript_environment.h"
@ -28,7 +29,6 @@
#include "shell/common/gin_helper/promise.h"
#include "shell/common/node_includes.h"
#include "shell/common/v8_value_serializer.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
namespace electron {
@ -179,11 +179,25 @@ void WebFrameMain::Send(v8::Isolate* isolate,
if (!CheckRenderFrame())
return;
mojo::AssociatedRemote<mojom::ElectronRenderer> electron_renderer;
render_frame_->GetRemoteAssociatedInterfaces()->GetInterface(
&electron_renderer);
electron_renderer->Message(internal, channel, std::move(message),
0 /* sender_id */);
GetRendererApi()->Message(internal, channel, std::move(message),
0 /* sender_id */);
}
const mojo::Remote<mojom::ElectronRenderer>& WebFrameMain::GetRendererApi() {
if (!renderer_api_) {
pending_receiver_ = renderer_api_.BindNewPipeAndPassReceiver();
if (render_frame_->IsRenderFrameCreated()) {
render_frame_->GetRemoteInterfaces()->GetInterface(
std::move(pending_receiver_));
}
renderer_api_.set_disconnect_handler(base::BindOnce(
&WebFrameMain::OnRendererConnectionError, weak_factory_.GetWeakPtr()));
}
return renderer_api_;
}
void WebFrameMain::OnRendererConnectionError() {
renderer_api_.reset();
}
void WebFrameMain::PostMessage(v8::Isolate* isolate,
@ -215,11 +229,8 @@ void WebFrameMain::PostMessage(v8::Isolate* isolate,
if (!CheckRenderFrame())
return;
mojo::AssociatedRemote<mojom::ElectronRenderer> electron_renderer;
render_frame_->GetRemoteAssociatedInterfaces()->GetInterface(
&electron_renderer);
electron_renderer->ReceivePostMessage(channel,
std::move(transferable_message));
GetRendererApi()->ReceivePostMessage(channel,
std::move(transferable_message));
}
int WebFrameMain::FrameTreeNodeID() const {
@ -335,6 +346,19 @@ void WebFrameMain::RenderFrameDeleted(content::RenderFrameHost* rfh) {
web_frame->MarkRenderFrameDisposed();
}
void WebFrameMain::RenderFrameCreated(content::RenderFrameHost* rfh) {
auto* web_frame = FromRenderFrameHost(rfh);
if (web_frame)
web_frame->Connect();
}
void WebFrameMain::Connect() {
if (pending_receiver_) {
render_frame_->GetRemoteInterfaces()->GetInterface(
std::move(pending_receiver_));
}
}
// static
v8::Local<v8::ObjectTemplate> WebFrameMain::FillObjectTemplate(
v8::Isolate* isolate,

12
shell/browser/api/electron_api_web_frame_main.h
View file

@ -9,6 +9,7 @@
#include <string>
#include <vector>
#include "base/memory/weak_ptr.h"
#include "base/process/process.h"
#include "gin/handle.h"
#include "gin/wrappable.h"
@ -51,11 +52,14 @@ class WebFrameMain : public gin::Wrappable<WebFrameMain>,
// Called to mark any RenderFrameHost as disposed by any WebFrameMain that
// may be holding a weak reference.
static void RenderFrameDeleted(content::RenderFrameHost* rfh);
static void RenderFrameCreated(content::RenderFrameHost* rfh);
// Mark RenderFrameHost as disposed and to no longer access it. This can
// occur upon frame navigation.
void MarkRenderFrameDisposed();
const mojo::Remote<mojom::ElectronRenderer>& GetRendererApi();
// gin::Wrappable
static gin::WrapperInfo kWrapperInfo;
static v8::Local<v8::ObjectTemplate> FillObjectTemplate(
@ -71,6 +75,7 @@ class WebFrameMain : public gin::Wrappable<WebFrameMain>,
// WebFrameMain can outlive its RenderFrameHost pointer so we need to check
// whether its been disposed of prior to accessing it.
bool CheckRenderFrame() const;
void Connect();
v8::Local<v8::Promise> ExecuteJavaScript(gin::Arguments* args,
const base::string16& code);
@ -100,12 +105,19 @@ class WebFrameMain : public gin::Wrappable<WebFrameMain>,
std::vector<content::RenderFrameHost*> Frames() const;
std::vector<content::RenderFrameHost*> FramesInSubtree() const;
void OnRendererConnectionError();
mojo::Remote<mojom::ElectronRenderer> renderer_api_;
mojo::PendingReceiver<mojom::ElectronRenderer> pending_receiver_;
content::RenderFrameHost* render_frame_ = nullptr;
// Whether the RenderFrameHost has been removed and that it should no longer
// be accessed.
bool render_frame_disposed_ = false;
base::WeakPtrFactory<WebFrameMain> weak_factory_{this};
DISALLOW_COPY_AND_ASSIGN(WebFrameMain);
};

12
shell/browser/electron_browser_client.cc
View file

@ -568,7 +568,7 @@ content::TtsPlatform* ElectronBrowserClient::GetTtsPlatform() {
}
void ElectronBrowserClient::OverrideWebkitPrefs(
content::RenderViewHost* host,
content::WebContents* web_contents,
blink::web_pref::WebPreferences* prefs) {
prefs->javascript_enabled = true;
prefs->web_security_enabled = true;
@ -597,7 +597,6 @@ void ElectronBrowserClient::OverrideWebkitPrefs(
? blink::mojom::PreferredColorScheme::kDark
: blink::mojom::PreferredColorScheme::kLight;
auto* web_contents = content::WebContents::FromRenderViewHost(host);
auto preloads =
SessionPreferences::GetValidPreloads(web_contents->GetBrowserContext());
if (!preloads.empty())
@ -1107,6 +1106,7 @@ void ElectronBrowserClient::RenderProcessHostDestroyed(
pending_processes_.erase(process_id);
renderer_is_subframe_.erase(process_id);
RemoveProcessPreferences(process_id);
host->RemoveObserver(this);
}
void ElectronBrowserClient::RenderProcessReady(
@ -1567,8 +1567,10 @@ void ElectronBrowserClient::OverrideURLLoaderFactoryParams(
}
#if defined(OS_WIN)
bool ElectronBrowserClient::PreSpawnRenderer(sandbox::TargetPolicy* policy,
RendererSpawnFlags flags) {
bool ElectronBrowserClient::PreSpawnChild(
sandbox::TargetPolicy* policy,
sandbox::policy::SandboxType sandbox_type,
ChildSpawnFlags flags) {
// Allow crashpad to communicate via named pipe.
sandbox::ResultCode result = policy->AddRule(
sandbox::TargetPolicy::SUBSYS_FILES,
@ -1737,7 +1739,7 @@ ElectronBrowserClient::CreateURLLoaderThrottles(
#if BUILDFLAG(ENABLE_PLUGINS) && BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
result.push_back(std::make_unique<PluginResponseInterceptorURLLoaderThrottle>(
request.resource_type, frame_tree_node_id));
request.destination, frame_tree_node_id));
#endif
return result;

7
shell/browser/electron_browser_client.h
View file

@ -92,7 +92,7 @@ class ElectronBrowserClient : public content::ContentBrowserClient,
CreateSpeechRecognitionManagerDelegate() override;
content::TtsPlatform* GetTtsPlatform() override;
void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
void OverrideWebkitPrefs(content::WebContents* web_contents,
blink::web_pref::WebPreferences* prefs) override;
SiteInstanceForNavigationType ShouldOverrideSiteInstanceForNavigation(
content::RenderFrameHost* current_rfh,
@ -219,8 +219,9 @@ class ElectronBrowserClient : public content::ContentBrowserClient,
bool is_for_isolated_world,
network::mojom::URLLoaderFactoryParams* factory_params) override;
#if defined(OS_WIN)
bool PreSpawnRenderer(sandbox::TargetPolicy* policy,
RendererSpawnFlags flags) override;
bool PreSpawnChild(sandbox::TargetPolicy* policy,
sandbox::policy::SandboxType sandbox_type,
ChildSpawnFlags flags) override;
#endif
bool BindAssociatedReceiverFromFrame(
content::RenderFrameHost* render_frame_host,

36
shell/browser/electron_browser_context.cc
View file

@ -8,6 +8,7 @@
#include <utility>
#include "base/barrier_closure.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/no_destructor.h"
@ -28,6 +29,8 @@
#include "components/proxy_config/proxy_config_pref_names.h"
#include "content/browser/blob_storage/chrome_blob_storage_context.h" // nogncheck
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/cors_origin_pattern_setter.h"
#include "content/public/browser/shared_cors_origin_access_list.h"
#include "content/public/browser/storage_partition.h"
#include "mojo/public/cpp/bindings/self_owned_receiver.h"
#include "net/base/escape.h"
@ -105,7 +108,9 @@ ElectronBrowserContext::ElectronBrowserContext(const std::string& partition,
: storage_policy_(new SpecialStoragePolicy),
protocol_registry_(new ProtocolRegistry),
in_memory_(in_memory),
ssl_config_(network::mojom::SSLConfig::New()) {
ssl_config_(network::mojom::SSLConfig::New()),
shared_cors_origin_access_list_(
content::SharedCorsOriginAccessList::Create()) {
user_agent_ = ElectronBrowserClient::Get()->GetUserAgent();
// Read options.
@ -431,9 +436,32 @@ void ElectronBrowserContext::SetCorsOriginAccessListForOrigin(
std::vector<network::mojom::CorsOriginPatternPtr> allow_patterns,
std::vector<network::mojom::CorsOriginPatternPtr> block_patterns,
base::OnceClosure closure) {
// TODO(nornagon): actually set the CORS access lists. This is called from
// extensions/browser/renderer_startup_helper.cc.
base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, std::move(closure));
auto& context_map = ElectronBrowserContext::browser_context_map();
auto barrier_closure =
BarrierClosure(1 + context_map.size(), std::move(closure));
for (auto& iter : context_map) {
if (iter.second) {
auto bc_setter = base::MakeRefCounted<content::CorsOriginPatternSetter>(
source_origin,
content::CorsOriginPatternSetter::ClonePatterns(allow_patterns),
content::CorsOriginPatternSetter::ClonePatterns(block_patterns),
barrier_closure);
ForEachStoragePartition(
std::move(iter.second.get()),
base::BindRepeating(&content::CorsOriginPatternSetter::SetLists,
base::RetainedRef(bc_setter.get())));
}
}
shared_cors_origin_access_list_->SetForOrigin(
source_origin, std::move(allow_patterns), std::move(block_patterns),
barrier_closure);
}
content::SharedCorsOriginAccessList*
ElectronBrowserContext::GetSharedCorsOriginAccessList() {
return shared_cors_origin_access_list_.get();
}
ResolveProxyHelper* ElectronBrowserContext::GetResolveProxyHelper() {

4
shell/browser/electron_browser_context.h
View file

@ -119,6 +119,7 @@ class ElectronBrowserContext
std::vector<network::mojom::CorsOriginPatternPtr> allow_patterns,
std::vector<network::mojom::CorsOriginPatternPtr> block_patterns,
base::OnceClosure closure) override;
content::SharedCorsOriginAccessList* GetSharedCorsOriginAccessList() override;
CookieChangeNotifier* cookie_change_notifier() const {
return cookie_change_notifier_.get();
@ -197,6 +198,9 @@ class ElectronBrowserContext
network::mojom::SSLConfigPtr ssl_config_;
mojo::Remote<network::mojom::SSLConfigClient> ssl_config_client_;
scoped_refptr<content::SharedCorsOriginAccessList>
shared_cors_origin_access_list_;
base::WeakPtrFactory<ElectronBrowserContext> weak_factory_{this};
DISALLOW_COPY_AND_ASSIGN(ElectronBrowserContext);

3
shell/browser/extensions/api/resources_private/resources_private_api.cc
View file

@ -64,9 +64,6 @@ void AddStringsForPdf(base::DictionaryValue* dict) {
void AddAdditionalDataForPdf(base::DictionaryValue* dict) {
#if BUILDFLAG(ENABLE_PDF)
dict->SetKey("pdfFormSaveEnabled",
base::Value(base::FeatureList::IsEnabled(
chrome_pdf::features::kSaveEditedPDFForm)));
dict->SetKey("documentPropertiesEnabled",
base::Value(base::FeatureList::IsEnabled(
chrome_pdf::features::kPdfViewerDocumentProperties)));

11
shell/browser/extensions/electron_extension_system.cc
View file

@ -24,6 +24,7 @@
#include "electron/buildflags/buildflags.h"
#include "extensions/browser/api/app_runtime/app_runtime_api.h"
#include "extensions/browser/extension_registry.h"
#include "extensions/browser/extension_user_script_manager.h"
#include "extensions/browser/info_map.h"
#include "extensions/browser/management_policy.h"
#include "extensions/browser/notification_types.h"
@ -31,7 +32,6 @@
#include "extensions/browser/quota_service.h"
#include "extensions/browser/runtime_data.h"
#include "extensions/browser/service_worker_manager.h"
#include "extensions/browser/shared_user_script_manager.h"
#include "extensions/browser/value_store/value_store_factory_impl.h"
#include "extensions/common/constants.h"
#include "extensions/common/file_util.h"
@ -84,8 +84,8 @@ void ElectronExtensionSystem::InitForRegularProfile(bool extensions_enabled) {
runtime_data_ =
std::make_unique<RuntimeData>(ExtensionRegistry::Get(browser_context_));
quota_service_ = std::make_unique<QuotaService>();
shared_user_script_manager_ =
std::make_unique<SharedUserScriptManager>(browser_context_);
extension_user_script_manager_ =
std::make_unique<ExtensionUserScriptManager>(browser_context_);
app_sorting_ = std::make_unique<NullAppSorting>();
extension_loader_ =
std::make_unique<ElectronExtensionLoader>(browser_context_);
@ -140,8 +140,9 @@ ServiceWorkerManager* ElectronExtensionSystem::service_worker_manager() {
return service_worker_manager_.get();
}
SharedUserScriptManager* ElectronExtensionSystem::shared_user_script_manager() {
return new SharedUserScriptManager(browser_context_);
ExtensionUserScriptManager*
ElectronExtensionSystem::extension_user_script_manager() {
return new ExtensionUserScriptManager(browser_context_);
}
StateStore* ElectronExtensionSystem::state_store() {

4
shell/browser/extensions/electron_extension_system.h
View file

@ -61,7 +61,7 @@ class ElectronExtensionSystem : public ExtensionSystem {
RuntimeData* runtime_data() override;
ManagementPolicy* management_policy() override;
ServiceWorkerManager* service_worker_manager() override;
SharedUserScriptManager* shared_user_script_manager() override;
ExtensionUserScriptManager* extension_user_script_manager() override;
StateStore* state_store() override;
StateStore* rules_store() override;
scoped_refptr<ValueStoreFactory> store_factory() override;
@ -103,7 +103,7 @@ class ElectronExtensionSystem : public ExtensionSystem {
std::unique_ptr<ServiceWorkerManager> service_worker_manager_;
std::unique_ptr<RuntimeData> runtime_data_;
std::unique_ptr<QuotaService> quota_service_;
std::unique_ptr<SharedUserScriptManager> shared_user_script_manager_;
std::unique_ptr<ExtensionUserScriptManager> extension_user_script_manager_;
std::unique_ptr<AppSorting> app_sorting_;
std::unique_ptr<ManagementPolicy> management_policy_;

5
shell/browser/lib/bluetooth_chooser.cc
View file

@ -50,6 +50,11 @@ void BluetoothChooser::SetAdapterPresence(AdapterPresence presence) {
switch (presence) {
case AdapterPresence::ABSENT:
case AdapterPresence::POWERED_OFF:
// Chrome currently directs the user to system preferences
// to grant bluetooth permission for this case, should we
// do something similar ?
// https://chromium-review.googlesource.com/c/chromium/src/+/2617129
case AdapterPresence::UNAUTHORIZED:
event_handler_.Run(content::BluetoothChooserEvent::CANCELLED, "");
break;
case AdapterPresence::POWERED_ON:

7
shell/browser/net/network_context_service.cc
View file

@ -8,8 +8,10 @@
#include "chrome/common/chrome_constants.h"
#include "content/public/browser/network_service_instance.h"
#include "content/public/browser/shared_cors_origin_access_list.h"
#include "net/net_buildflags.h"
#include "services/network/network_service.h"
#include "services/network/public/cpp/cors/origin_access_list.h"
#include "shell/browser/browser_process_impl.h"
#include "shell/browser/electron_browser_client.h"
#include "shell/browser/net/system_network_context_manager.h"
@ -40,6 +42,11 @@ void NetworkContextService::ConfigureNetworkContextParams(
network_context_params->user_agent = browser_context_->GetUserAgent();
network_context_params->cors_origin_access_list =
browser_context_->GetSharedCorsOriginAccessList()
->GetOriginAccessList()
.CreateCorsOriginAccessPatternsList();
network_context_params->accept_language =
net::HttpUtil::GenerateAcceptLanguageHeader(
ElectronBrowserClient::Get()->GetApplicationLocale());

104
shell/browser/printing/print_preview_message_handler.cc
View file

@ -17,7 +17,6 @@
#include "chrome/browser/printing/printer_query.h"
#include "components/printing/browser/print_composite_client.h"
#include "components/printing/browser/print_manager_utils.h"
#include "components/printing/common/print_messages.h"
#include "components/services/print_compositor/public/cpp/print_service_mojo_types.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
@ -53,67 +52,50 @@ void StopWorker(int document_cookie) {
PrintPreviewMessageHandler::PrintPreviewMessageHandler(
content::WebContents* web_contents)
: content::WebContentsObserver(web_contents) {
: web_contents_(web_contents) {
DCHECK(web_contents);
}
PrintPreviewMessageHandler::~PrintPreviewMessageHandler() = default;
bool PrintPreviewMessageHandler::OnMessageReceived(
const IPC::Message& message,
content::RenderFrameHost* render_frame_host) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(PrintPreviewMessageHandler, message,
render_frame_host)
IPC_MESSAGE_HANDLER(PrintHostMsg_MetafileReadyForPrinting,
OnMetafileReadyForPrinting)
IPC_MESSAGE_HANDLER(PrintHostMsg_DidPreviewPage, OnDidPreviewPage)
IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrepareDocumentForPreview,
OnDidPrepareForDocumentToPdf)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
}
void PrintPreviewMessageHandler::OnMetafileReadyForPrinting(
content::RenderFrameHost* render_frame_host,
const printing::mojom::DidPreviewDocumentParams& params,
const printing::mojom::PreviewIds& ids) {
void PrintPreviewMessageHandler::MetafileReadyForPrinting(
printing::mojom::DidPreviewDocumentParamsPtr params,
int32_t request_id) {
// Always try to stop the worker.
StopWorker(params.document_cookie);
StopWorker(params->document_cookie);
if (params.expected_pages_count == 0) {
RejectPromise(ids.request_id);
if (params->expected_pages_count == 0) {
RejectPromise(request_id);
return;
}
const base::ReadOnlySharedMemoryRegion& metafile =
params.content->metafile_data_region;
params->content->metafile_data_region;
if (printing::IsOopifEnabled()) {
auto* client =
printing::PrintCompositeClient::FromWebContents(web_contents());
printing::PrintCompositeClient::FromWebContents(web_contents_);
DCHECK(client);
auto callback = base::BindOnce(
&PrintPreviewMessageHandler::OnCompositeDocumentToPdfDone,
weak_ptr_factory_.GetWeakPtr(), ids);
weak_ptr_factory_.GetWeakPtr(), request_id);
client->DoCompleteDocumentToPdf(
params.document_cookie, params.expected_pages_count,
params->document_cookie, params->expected_pages_count,
mojo::WrapCallbackWithDefaultInvokeIfNotRun(
std::move(callback),
printing::mojom::PrintCompositor::Status::kCompositingFailure,
base::ReadOnlySharedMemoryRegion()));
} else {
ResolvePromise(
ids.request_id,
request_id,
base::RefCountedSharedMemoryMapping::CreateFromWholeRegion(metafile));
}
}
void PrintPreviewMessageHandler::OnPrepareForDocumentToPdfDone(
const printing::mojom::PreviewIds& ids,
int32_t request_id,
printing::mojom::PrintCompositor::Status status) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (status != printing::mojom::PrintCompositor::Status::kSuccess) {
@ -121,49 +103,53 @@ void PrintPreviewMessageHandler::OnPrepareForDocumentToPdfDone(
}
}
void PrintPreviewMessageHandler::OnDidPrepareForDocumentToPdf(
content::RenderFrameHost* render_frame_host,
int document_cookie,
const printing::mojom::PreviewIds& ids) {
void PrintPreviewMessageHandler::DidPrepareDocumentForPreview(
int32_t document_cookie,
int32_t request_id) {
if (printing::IsOopifEnabled()) {
auto* client =
printing::PrintCompositeClient::FromWebContents(web_contents());
printing::PrintCompositeClient::FromWebContents(web_contents_);
DCHECK(client);
if (client->GetIsDocumentConcurrentlyComposited(document_cookie))
return;
auto* focused_frame = web_contents_->GetFocusedFrame();
auto* rfh = focused_frame && focused_frame->HasSelection()
? focused_frame
: web_contents_->GetMainFrame();
client->DoPrepareForDocumentToPdf(
document_cookie, render_frame_host,
document_cookie, rfh,
mojo::WrapCallbackWithDefaultInvokeIfNotRun(
base::BindOnce(
&PrintPreviewMessageHandler::OnPrepareForDocumentToPdfDone,
weak_ptr_factory_.GetWeakPtr(), ids),
weak_ptr_factory_.GetWeakPtr(), request_id),
printing::mojom::PrintCompositor::Status::kCompositingFailure));
}
}
void PrintPreviewMessageHandler::OnCompositeDocumentToPdfDone(
const printing::mojom::PreviewIds& ids,
int32_t request_id,
printing::mojom::PrintCompositor::Status status,
base::ReadOnlySharedMemoryRegion region) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
if (status != printing::mojom::PrintCompositor::Status::kSuccess) {
LOG(ERROR) << "Compositing pdf failed with error " << status;
RejectPromise(ids.request_id);
RejectPromise(request_id);
return;
}
ResolvePromise(
ids.request_id,
request_id,
base::RefCountedSharedMemoryMapping::CreateFromWholeRegion(region));
}
void PrintPreviewMessageHandler::OnCompositePdfPageDone(
int page_number,
int document_cookie,
const printing::mojom::PreviewIds& ids,
int32_t request_id,
printing::mojom::PrintCompositor::Status status,
base::ReadOnlySharedMemoryRegion region) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
@ -173,31 +159,35 @@ void PrintPreviewMessageHandler::OnCompositePdfPageDone(
}
}
void PrintPreviewMessageHandler::OnDidPreviewPage(
content::RenderFrameHost* render_frame_host,
const printing::mojom::DidPreviewPageParams& params,
const printing::mojom::PreviewIds& ids) {
int page_number = params.page_number;
const printing::mojom::DidPrintContentParams& content = *params.content;
void PrintPreviewMessageHandler::DidPreviewPage(
printing::mojom::DidPreviewPageParamsPtr params,
int32_t request_id) {
int page_number = params->page_number;
const printing::mojom::DidPrintContentParams& content = *(params->content);
if (page_number < printing::FIRST_PAGE_INDEX ||
!content.metafile_data_region.IsValid()) {
RejectPromise(ids.request_id);
RejectPromise(request_id);
return;
}
if (printing::IsOopifEnabled()) {
auto* client =
printing::PrintCompositeClient::FromWebContents(web_contents());
printing::PrintCompositeClient::FromWebContents(web_contents_);
DCHECK(client);
auto* focused_frame = web_contents_->GetFocusedFrame();
auto* rfh = focused_frame && focused_frame->HasSelection()
? focused_frame
: web_contents_->GetMainFrame();
// Use utility process to convert skia metafile to pdf.
client->DoCompositePageToPdf(
params.document_cookie, render_frame_host, content,
params->document_cookie, rfh, content,
mojo::WrapCallbackWithDefaultInvokeIfNotRun(
base::BindOnce(&PrintPreviewMessageHandler::OnCompositePdfPageDone,
weak_ptr_factory_.GetWeakPtr(), page_number,
params.document_cookie, ids),
params->document_cookie, request_id),
printing::mojom::PrintCompositor::Status::kCompositingFailure,
base::ReadOnlySharedMemoryRegion()));
}
@ -217,12 +207,6 @@ void PrintPreviewMessageHandler::PrintPreviewCancelled(int32_t document_cookie,
RejectPromise(request_id);
}
void PrintPreviewMessageHandler::CheckForCancel(
int32_t request_id,
CheckForCancelCallback callback) {
std::move(callback).Run(false);
}
void PrintPreviewMessageHandler::PrintToPDF(
base::DictionaryValue options,
gin_helper::Promise<v8::Local<v8::Value>> promise) {
@ -230,10 +214,10 @@ void PrintPreviewMessageHandler::PrintToPDF(
options.GetInteger(printing::kPreviewRequestID, &request_id);
promise_map_.emplace(request_id, std::move(promise));
auto* focused_frame = web_contents()->GetFocusedFrame();
auto* focused_frame = web_contents_->GetFocusedFrame();
auto* rfh = focused_frame && focused_frame->HasSelection()
? focused_frame
: web_contents()->GetMainFrame();
: web_contents_->GetMainFrame();
if (!print_render_frame_.is_bound()) {
rfh->GetRemoteAssociatedInterfaces()->GetInterface(&print_render_frame_);

46
shell/browser/printing/print_preview_message_handler.h
View file

@ -11,16 +11,12 @@
#include "base/memory/weak_ptr.h"
#include "components/printing/common/print.mojom.h"
#include "components/services/print_compositor/public/mojom/print_compositor.mojom.h"
#include "content/public/browser/web_contents_observer.h"
#include "content/public/browser/web_contents_user_data.h"
#include "mojo/public/cpp/bindings/associated_receiver.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "shell/common/gin_helper/promise.h"
#include "v8/include/v8.h"
struct PrintHostMsg_DidPreviewDocument_Params;
struct PrintHostMsg_DidPreviewPage_Params;
namespace content {
class RenderFrameHost;
}
@ -29,8 +25,7 @@ namespace electron {
// Manages the print preview handling for a WebContents.
class PrintPreviewMessageHandler
: public content::WebContentsObserver,
public printing::mojom::PrintPreviewUI,
: public printing::mojom::PrintPreviewUI,
public content::WebContentsUserData<PrintPreviewMessageHandler> {
public:
~PrintPreviewMessageHandler() override;
@ -38,38 +33,23 @@ class PrintPreviewMessageHandler
void PrintToPDF(base::DictionaryValue options,
gin_helper::Promise<v8::Local<v8::Value>> promise);
protected:
// content::WebContentsObserver implementation.
bool OnMessageReceived(const IPC::Message& message,
content::RenderFrameHost* render_frame_host) override;
private:
friend class content::WebContentsUserData<PrintPreviewMessageHandler>;
explicit PrintPreviewMessageHandler(content::WebContents* web_contents);
void OnMetafileReadyForPrinting(
content::RenderFrameHost* render_frame_host,
const printing::mojom::DidPreviewDocumentParams& params,
const printing::mojom::PreviewIds& ids);
void OnCompositeDocumentToPdfDone(
const printing::mojom::PreviewIds& ids,
int32_t request_id,
printing::mojom::PrintCompositor::Status status,
base::ReadOnlySharedMemoryRegion region);
void OnPrepareForDocumentToPdfDone(
const printing::mojom::PreviewIds& ids,
int32_t request_id,
printing::mojom::PrintCompositor::Status status);
void OnDidPrepareForDocumentToPdf(content::RenderFrameHost* render_frame_host,
int document_cookie,
const printing::mojom::PreviewIds& ids);
void OnCompositePdfPageDone(int page_number,
int document_cookie,
const printing::mojom::PreviewIds& ids,
int32_t request_id,
printing::mojom::PrintCompositor::Status status,
base::ReadOnlySharedMemoryRegion region);
void OnDidPreviewPage(content::RenderFrameHost* render_frame_host,
const printing::mojom::DidPreviewPageParams& params,
const printing::mojom::PreviewIds& ids);
// printing::mojo::PrintPreviewUI:
void SetOptionsFromDocument(
@ -80,8 +60,20 @@ class PrintPreviewMessageHandler
int32_t request_id) override;
void PrinterSettingsInvalid(int32_t document_cookie,
int32_t request_id) override {}
void CheckForCancel(int32_t request_id,
CheckForCancelCallback callback) override;
void DidPrepareDocumentForPreview(int32_t document_cookie,
int32_t request_id) override;
void DidPreviewPage(printing::mojom::DidPreviewPageParamsPtr params,
int32_t request_id) override;
void MetafileReadyForPrinting(
printing::mojom::DidPreviewDocumentParamsPtr params,
int32_t request_id) override;
void DidGetDefaultPageLayout(
printing::mojom::PageSizeMarginsPtr page_layout_in_points,
const gfx::Rect& printable_area_in_points,
bool has_custom_page_size_style,
int32_t request_id) override {}
void DidStartPreview(printing::mojom::DidStartPreviewParamsPtr params,
int32_t request_id) override {}
gin_helper::Promise<v8::Local<v8::Value>> GetPromise(int request_id);
@ -92,6 +84,8 @@ class PrintPreviewMessageHandler
using PromiseMap = std::map<int, gin_helper::Promise<v8::Local<v8::Value>>>;
PromiseMap promise_map_;
content::WebContents* web_contents_ = nullptr;
mojo::AssociatedRemote<printing::mojom::PrintRenderFrame> print_render_frame_;
mojo::AssociatedReceiver<printing::mojom::PrintPreviewUI> receiver_{this};

2
shell/common/api/api.mojom
View file

@ -14,8 +14,6 @@ interface ElectronRenderer {
ReceivePostMessage(string channel, blink.mojom.TransferableMessage message);
NotifyUserActivation();
TakeHeapSnapshot(handle file) => (bool success);
};

46
shell/common/gin_converters/blink_converter.cc
View file

@ -347,15 +347,16 @@ v8::Local<v8::Value> Converter<blink::mojom::ContextMenuDataMediaType>::ToV8(
}
// static
v8::Local<v8::Value> Converter<blink::ContextMenuDataInputFieldType>::ToV8(
v8::Local<v8::Value>
Converter<blink::mojom::ContextMenuDataInputFieldType>::ToV8(
v8::Isolate* isolate,
const blink::ContextMenuDataInputFieldType& in) {
const blink::mojom::ContextMenuDataInputFieldType& in) {
switch (in) {
case blink::ContextMenuDataInputFieldType::kPlainText:
case blink::mojom::ContextMenuDataInputFieldType::kPlainText:
return StringToV8(isolate, "plainText");
case blink::ContextMenuDataInputFieldType::kPassword:
case blink::mojom::ContextMenuDataInputFieldType::kPassword:
return StringToV8(isolate, "password");
case blink::ContextMenuDataInputFieldType::kOther:
case blink::mojom::ContextMenuDataInputFieldType::kOther:
return StringToV8(isolate, "other");
default:
return StringToV8(isolate, "none");
@ -393,31 +394,24 @@ v8::Local<v8::Value> EditFlagsToV8(v8::Isolate* isolate, int editFlags) {
v8::Local<v8::Value> MediaFlagsToV8(v8::Isolate* isolate, int mediaFlags) {
gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
dict.Set("inError",
!!(mediaFlags & blink::WebContextMenuData::kMediaInError));
dict.Set("isPaused",
!!(mediaFlags & blink::WebContextMenuData::kMediaPaused));
dict.Set("isMuted", !!(mediaFlags & blink::WebContextMenuData::kMediaMuted));
dict.Set("canSave",
!!(mediaFlags & blink::WebContextMenuData::kMediaCanSave));
dict.Set("hasAudio",
!!(mediaFlags & blink::WebContextMenuData::kMediaHasAudio));
dict.Set("isLooping", !!(mediaFlags & blink::WebContextMenuData::kMediaLoop));
dict.Set("inError", !!(mediaFlags & blink::ContextMenuData::kMediaInError));
dict.Set("isPaused", !!(mediaFlags & blink::ContextMenuData::kMediaPaused));
dict.Set("isMuted", !!(mediaFlags & blink::ContextMenuData::kMediaMuted));
dict.Set("canSave", !!(mediaFlags & blink::ContextMenuData::kMediaCanSave));
dict.Set("hasAudio", !!(mediaFlags & blink::ContextMenuData::kMediaHasAudio));
dict.Set("isLooping", !!(mediaFlags & blink::ContextMenuData::kMediaLoop));
dict.Set("isControlsVisible",
!!(mediaFlags & blink::WebContextMenuData::kMediaControls));
!!(mediaFlags & blink::ContextMenuData::kMediaControls));
dict.Set("canToggleControls",
!!(mediaFlags & blink::WebContextMenuData::kMediaCanToggleControls));
dict.Set("canPrint",
!!(mediaFlags & blink::WebContextMenuData::kMediaCanPrint));
!!(mediaFlags & blink::ContextMenuData::kMediaCanToggleControls));
dict.Set("canPrint", !!(mediaFlags & blink::ContextMenuData::kMediaCanPrint));
dict.Set("canRotate",
!!(mediaFlags & blink::WebContextMenuData::kMediaCanRotate));
dict.Set(
"canShowPictureInPicture",
!!(mediaFlags & blink::WebContextMenuData::kMediaCanPictureInPicture));
!!(mediaFlags & blink::ContextMenuData::kMediaCanRotate));
dict.Set("canShowPictureInPicture",
!!(mediaFlags & blink::ContextMenuData::kMediaCanPictureInPicture));
dict.Set("isShowingPictureInPicture",
!!(mediaFlags & blink::WebContextMenuData::kMediaPictureInPicture));
dict.Set("canLoop",
!!(mediaFlags & blink::WebContextMenuData::kMediaCanLoop));
!!(mediaFlags & blink::ContextMenuData::kMediaPictureInPicture));
dict.Set("canLoop", !!(mediaFlags & blink::ContextMenuData::kMediaCanLoop));
return ConvertToV8(isolate, dict);
}

6
shell/common/gin_converters/blink_converter.h
View file

@ -6,10 +6,10 @@
#define SHELL_COMMON_GIN_CONVERTERS_BLINK_CONVERTER_H_
#include "gin/converter.h"
#include "third_party/blink/public/common/context_menu_data/context_menu_data.h"
#include "third_party/blink/public/common/input/web_input_event.h"
#include "third_party/blink/public/common/messaging/cloneable_message.h"
#include "third_party/blink/public/common/web_cache/web_cache_resource_type_stats.h"
#include "third_party/blink/public/web/web_context_menu_data.h"
namespace blink {
class WebMouseEvent;
@ -74,10 +74,10 @@ struct Converter<blink::mojom::ContextMenuDataMediaType> {
};
template <>
struct Converter<blink::ContextMenuDataInputFieldType> {
struct Converter<blink::mojom::ContextMenuDataInputFieldType> {
static v8::Local<v8::Value> ToV8(
v8::Isolate* isolate,
const blink::ContextMenuDataInputFieldType& in);
const blink::mojom::ContextMenuDataInputFieldType& in);
};
template <>

40
shell/common/gin_converters/content_converter.cc
View file

@ -10,7 +10,6 @@
#include "content/public/browser/context_menu_params.h"
#include "content/public/browser/native_web_keyboard_event.h"
#include "content/public/browser/web_contents.h"
#include "content/public/common/untrustworthy_context_menu_params.h"
#include "shell/browser/api/electron_api_web_contents.h"
#include "shell/browser/web_contents_permission_helper.h"
#include "shell/common/gin_converters/blink_converter.h"
@ -18,6 +17,7 @@
#include "shell/common/gin_converters/gfx_converter.h"
#include "shell/common/gin_converters/gurl_converter.h"
#include "shell/common/gin_helper/dictionary.h"
#include "third_party/blink/public/common/context_menu_data/untrustworthy_context_menu_params.h"
#include "ui/events/keycodes/dom/keycode_converter.h"
#include "ui/events/keycodes/keyboard_code_conversion.h"
@ -25,36 +25,36 @@ namespace {
void ExecuteCommand(content::WebContents* web_contents,
int action,
const content::CustomContextMenuContext& context) {
const blink::CustomContextMenuContext& context) {
web_contents->ExecuteCustomContextMenuCommand(action, context);
}
// Forward declaration for nested recursive call.
v8::Local<v8::Value> MenuToV8(v8::Isolate* isolate,
content::WebContents* web_contents,
const content::CustomContextMenuContext& context,
const std::vector<content::MenuItem>& menu);
const blink::CustomContextMenuContext& context,
const std::vector<blink::MenuItem>& menu);
v8::Local<v8::Value> MenuItemToV8(
v8::Isolate* isolate,
content::WebContents* web_contents,
const content::CustomContextMenuContext& context,
const content::MenuItem& item) {
const blink::CustomContextMenuContext& context,
const blink::MenuItem& item) {
gin_helper::Dictionary v8_item = gin::Dictionary::CreateEmpty(isolate);
switch (item.type) {
case content::MenuItem::CHECKABLE_OPTION:
case content::MenuItem::GROUP:
case blink::MenuItem::CHECKABLE_OPTION:
case blink::MenuItem::GROUP:
v8_item.Set("checked", item.checked);
FALLTHROUGH;
case content::MenuItem::OPTION:
case content::MenuItem::SUBMENU:
case blink::MenuItem::OPTION:
case blink::MenuItem::SUBMENU:
v8_item.Set("label", item.label);
v8_item.Set("enabled", item.enabled);
FALLTHROUGH;
default:
v8_item.Set("type", item.type);
}
if (item.type == content::MenuItem::SUBMENU)
if (item.type == blink::MenuItem::SUBMENU)
v8_item.Set("submenu",
MenuToV8(isolate, web_contents, context, item.submenu));
else if (item.action > 0)
@ -65,8 +65,8 @@ v8::Local<v8::Value> MenuItemToV8(
v8::Local<v8::Value> MenuToV8(v8::Isolate* isolate,
content::WebContents* web_contents,
const content::CustomContextMenuContext& context,
const std::vector<content::MenuItem>& menu) {
const blink::CustomContextMenuContext& context,
const std::vector<blink::MenuItem>& menu) {
std::vector<v8::Local<v8::Value>> v8_menu;
v8_menu.reserve(menu.size());
for (const auto& menu_item : menu)
@ -110,19 +110,19 @@ struct Converter<ui::MenuSourceType> {
};
// static
v8::Local<v8::Value> Converter<content::MenuItem::Type>::ToV8(
v8::Local<v8::Value> Converter<blink::MenuItem::Type>::ToV8(
v8::Isolate* isolate,
const content::MenuItem::Type& val) {
const blink::MenuItem::Type& val) {
switch (val) {
case content::MenuItem::CHECKABLE_OPTION:
case blink::MenuItem::CHECKABLE_OPTION:
return StringToV8(isolate, "checkbox");
case content::MenuItem::GROUP:
case blink::MenuItem::GROUP:
return StringToV8(isolate, "radio");
case content::MenuItem::SEPARATOR:
case blink::MenuItem::SEPARATOR:
return StringToV8(isolate, "separator");
case content::MenuItem::SUBMENU:
case blink::MenuItem::SUBMENU:
return StringToV8(isolate, "submenu");
case content::MenuItem::OPTION:
case blink::MenuItem::OPTION:
default:
return StringToV8(isolate, "normal");
}

6
shell/common/gin_converters/content_converter.h
View file

@ -8,10 +8,10 @@
#include <utility>
#include "content/public/browser/permission_type.h"
#include "content/public/common/menu_item.h"
#include "content/public/common/referrer.h"
#include "content/public/common/stop_find_action.h"
#include "gin/converter.h"
#include "third_party/blink/public/common/context_menu_data/menu_item.h"
#include "third_party/blink/public/mojom/permissions/permission_status.mojom.h"
namespace content {
@ -26,9 +26,9 @@ using ContextMenuParamsWithWebContents =
namespace gin {
template <>
struct Converter<content::MenuItem::Type> {
struct Converter<blink::MenuItem::Type> {
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
const content::MenuItem::Type& val);
const blink::MenuItem::Type& val);
};
template <>

63
shell/renderer/electron_api_service_impl.cc
View file

@ -104,21 +104,42 @@ ElectronApiServiceImpl::ElectronApiServiceImpl(
content::RenderFrame* render_frame,
RendererClientBase* renderer_client)
: content::RenderFrameObserver(render_frame),
renderer_client_(renderer_client) {}
renderer_client_(renderer_client) {
registry_.AddInterface(base::BindRepeating(&ElectronApiServiceImpl::BindTo,
base::Unretained(this)));
}
void ElectronApiServiceImpl::BindTo(
mojo::PendingAssociatedReceiver<mojom::ElectronRenderer> receiver) {
// Note: BindTo might be called for multiple times.
if (receiver_.is_bound())
receiver_.reset();
mojo::PendingReceiver<mojom::ElectronRenderer> receiver) {
if (document_created_) {
if (receiver_.is_bound())
receiver_.reset();
receiver_.Bind(std::move(receiver));
receiver_.set_disconnect_handler(
base::BindOnce(&ElectronApiServiceImpl::OnConnectionError, GetWeakPtr()));
receiver_.Bind(std::move(receiver));
receiver_.set_disconnect_handler(base::BindOnce(
&ElectronApiServiceImpl::OnConnectionError, GetWeakPtr()));
} else {
pending_receiver_ = std::move(receiver);
}
}
void ElectronApiServiceImpl::OnInterfaceRequestForFrame(
const std::string& interface_name,
mojo::ScopedMessagePipeHandle* interface_pipe) {
registry_.TryBindInterface(interface_name, interface_pipe);
}
void ElectronApiServiceImpl::DidCreateDocumentElement() {
document_created_ = true;
if (pending_receiver_) {
if (receiver_.is_bound())
receiver_.reset();
receiver_.Bind(std::move(pending_receiver_));
receiver_.set_disconnect_handler(base::BindOnce(
&ElectronApiServiceImpl::OnConnectionError, GetWeakPtr()));
}
}
void ElectronApiServiceImpl::OnDestruct() {
@ -134,25 +155,6 @@ void ElectronApiServiceImpl::Message(bool internal,
const std::string& channel,
blink::CloneableMessage arguments,
int32_t sender_id) {
// Don't handle browser messages before document element is created.
//
// Note: It is probably better to save the message and then replay it after
// document is ready, but current behavior has been there since the first
// day of Electron, and no one has complained so far.
//
// Reason 1:
// When we receive a message from the browser, we try to transfer it
// to a web page, and when we do that Blink creates an empty
// document element if it hasn't been created yet, and it makes our init
// script to run while `window.location` is still "about:blank".
// (See https://github.com/electron/electron/pull/1044.)
//
// Reason 2:
// The libuv message loop integration would be broken for unkown reasons.
// (See https://github.com/electron/electron/issues/19368.)
if (!document_created_)
return;
blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
if (!frame)
return;
@ -196,13 +198,6 @@ void ElectronApiServiceImpl::ReceivePostMessage(
0);
}
void ElectronApiServiceImpl::NotifyUserActivation() {
blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
if (frame)
frame->NotifyUserActivation(
blink::mojom::UserActivationNotificationType::kInteraction);
}
void ElectronApiServiceImpl::TakeHeapSnapshot(
mojo::ScopedHandle file,
TakeHeapSnapshotCallback callback) {

21
shell/renderer/electron_api_service_impl.h
View file

@ -5,6 +5,7 @@
#ifndef SHELL_RENDERER_ELECTRON_API_SERVICE_IMPL_H_
#define SHELL_RENDERER_ELECTRON_API_SERVICE_IMPL_H_
#include <queue>
#include <string>
#include "base/memory/weak_ptr.h"
@ -12,8 +13,8 @@
#include "content/public/renderer/render_frame_observer.h"
#include "electron/buildflags/buildflags.h"
#include "electron/shell/common/api/api.mojom.h"
#include "mojo/public/cpp/bindings/associated_receiver.h"
#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/receiver.h"
namespace electron {
@ -24,9 +25,9 @@ class ElectronApiServiceImpl : public mojom::ElectronRenderer,
public:
ElectronApiServiceImpl(content::RenderFrame* render_frame,
RendererClientBase* renderer_client);
~ElectronApiServiceImpl() override;
void BindTo(
mojo::PendingAssociatedReceiver<mojom::ElectronRenderer> receiver);
void BindTo(mojo::PendingReceiver<mojom::ElectronRenderer> receiver);
void Message(bool internal,
const std::string& channel,
@ -34,17 +35,19 @@ class ElectronApiServiceImpl : public mojom::ElectronRenderer,
int32_t sender_id) override;
void ReceivePostMessage(const std::string& channel,
blink::TransferableMessage message) override;
void NotifyUserActivation() override;
void TakeHeapSnapshot(mojo::ScopedHandle file,
TakeHeapSnapshotCallback callback) override;
void ProcessPendingMessages();
base::WeakPtr<ElectronApiServiceImpl> GetWeakPtr() {
return weak_factory_.GetWeakPtr();
}
private:
~ElectronApiServiceImpl() override;
void OnInterfaceRequestForFrame(
const std::string& interface_name,
mojo::ScopedMessagePipeHandle* interface_pipe) override;
private:
// RenderFrameObserver implementation.
void DidCreateDocumentElement() override;
void OnDestruct() override;
@ -53,8 +56,10 @@ class ElectronApiServiceImpl : public mojom::ElectronRenderer,
// Whether the DOM document element has been created.
bool document_created_ = false;
service_manager::BinderRegistry registry_;
mojo::AssociatedReceiver<mojom::ElectronRenderer> receiver_{this};
mojo::PendingReceiver<mojom::ElectronRenderer> pending_receiver_;
mojo::Receiver<mojom::ElectronRenderer> receiver_{this};
RendererClientBase* renderer_client_;
base::WeakPtrFactory<ElectronApiServiceImpl> weak_factory_{this};

21
shell/renderer/renderer_client_base.cc
View file

@ -75,9 +75,7 @@
#include "extensions/common/extensions_client.h"
#include "extensions/renderer/dispatcher.h"
#include "extensions/renderer/extension_frame_helper.h"
#include "extensions/renderer/guest_view/extensions_guest_view_container.h"
#include "extensions/renderer/guest_view/extensions_guest_view_container_dispatcher.h"
#include "extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container.h"
#include "extensions/renderer/guest_view/mime_handler_view/mime_handler_view_container_manager.h"
#include "shell/common/extensions/electron_extensions_client.h"
#include "shell/renderer/extensions/electron_extensions_renderer_client.h"
@ -256,10 +254,7 @@ void RendererClientBase::RenderFrameCreated(
// Note: ElectronApiServiceImpl has to be created now to capture the
// DidCreateDocumentElement event.
auto* service = new ElectronApiServiceImpl(render_frame, this);
render_frame->GetAssociatedInterfaceRegistry()->AddInterface(
base::BindRepeating(&ElectronApiServiceImpl::BindTo,
service->GetWeakPtr()));
new ElectronApiServiceImpl(render_frame, this);
content::RenderView* render_view = render_frame->GetRenderView();
if (render_frame->IsMainFrame() && render_view) {
@ -352,20 +347,6 @@ void RendererClientBase::DidSetUserAgent(const std::string& user_agent) {
#endif
}
guest_view::GuestViewContainer* RendererClientBase::CreateBrowserPluginDelegate(
content::RenderFrame* render_frame,
const content::WebPluginInfo& info,
const std::string& mime_type,
const GURL& original_url) {
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
// TODO(nornagon): check the mime type isn't content::kBrowserPluginMimeType?
return new extensions::MimeHandlerViewContainer(render_frame, info, mime_type,
original_url);
#else
return nullptr;
#endif
}
bool RendererClientBase::IsPluginHandledExternally(
content::RenderFrame* render_frame,
const blink::WebElement& plugin_element,

12
shell/renderer/renderer_client_base.h
View file

@ -7,6 +7,7 @@
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include "content/public/renderer/content_renderer_client.h"
@ -40,12 +41,10 @@ struct WebPluginInfo;
}
#endif
namespace guest_view {
class GuestViewContainer;
}
namespace electron {
class ElectronApiServiceImpl;
#if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
class ElectronExtensionsRendererClient;
#endif
@ -108,11 +107,6 @@ class RendererClientBase : public content::ContentRendererClient
override;
bool IsKeySystemsUpdateNeeded() override;
void DidSetUserAgent(const std::string& user_agent) override;
guest_view::GuestViewContainer* CreateBrowserPluginDelegate(
content::RenderFrame* render_frame,
const content::WebPluginInfo& info,
const std::string& mime_type,
const GURL& original_url);
bool IsPluginHandledExternally(content::RenderFrame* render_frame,
const blink::WebElement& plugin_element,
const GURL& original_url,