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