2016-01-23 06:29:47 -07:00
|
|
|
// Copyright (c) 2016 GitHub, Inc.
|
|
|
|
// Use of this source code is governed by the MIT license that can be
|
|
|
|
// found in the LICENSE file.
|
|
|
|
|
2019-06-19 14:46:59 -06:00
|
|
|
#include "shell/browser/web_contents_permission_helper.h"
|
2016-01-23 06:29:47 -07:00
|
|
|
|
2024-01-10 18:00:37 -07:00
|
|
|
#include <string_view>
|
2018-09-12 19:57:23 -06:00
|
|
|
#include <utility>
|
2016-01-23 06:29:47 -07:00
|
|
|
|
2016-01-31 12:13:29 -07:00
|
|
|
#include "content/public/browser/browser_context.h"
|
2016-01-30 04:19:18 -07:00
|
|
|
#include "content/public/browser/render_process_host.h"
|
2022-01-10 15:31:39 -07:00
|
|
|
#include "content/public/browser/web_contents_user_data.h"
|
2020-02-04 13:19:40 -07:00
|
|
|
#include "shell/browser/electron_permission_manager.h"
|
2022-07-20 02:09:14 -06:00
|
|
|
// #include "shell/browser/media/media_stream_devices_controller.h"
|
|
|
|
#include "components/content_settings/core/common/content_settings.h"
|
|
|
|
#include "components/webrtc/media_stream_devices_controller.h"
|
|
|
|
#include "shell/browser/media/media_capture_devices_dispatcher.h"
|
2016-01-23 06:29:47 -07:00
|
|
|
|
2018-08-28 08:05:08 -06:00
|
|
|
namespace {
|
|
|
|
|
2024-01-10 18:00:37 -07:00
|
|
|
constexpr std::string_view MediaStreamTypeToString(
|
2023-06-12 01:55:22 -06:00
|
|
|
blink::mojom::MediaStreamType type) {
|
2018-08-28 08:05:08 -06:00
|
|
|
switch (type) {
|
2019-07-02 19:22:09 -06:00
|
|
|
case blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE:
|
2018-08-28 08:05:08 -06:00
|
|
|
return "audio";
|
2019-07-02 19:22:09 -06:00
|
|
|
case blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE:
|
2018-08-28 08:05:08 -06:00
|
|
|
return "video";
|
|
|
|
default:
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2019-06-19 15:23:04 -06:00
|
|
|
namespace electron {
|
2016-01-23 06:29:47 -07:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2024-02-14 10:33:32 -07:00
|
|
|
[[nodiscard]] content::DesktopMediaID GetScreenId(
|
|
|
|
const std::vector<std::string>& requested_video_device_ids) {
|
|
|
|
if (!requested_video_device_ids.empty() &&
|
|
|
|
!requested_video_device_ids.front().empty())
|
|
|
|
return content::DesktopMediaID::Parse(requested_video_device_ids.front());
|
|
|
|
|
|
|
|
// If the device id wasn't specified then this is a screen capture request
|
|
|
|
// (i.e. chooseDesktopMedia() API wasn't used to generate device id).
|
|
|
|
return content::DesktopMediaID(content::DesktopMediaID::TYPE_SCREEN,
|
|
|
|
-1 /* kFullDesktopScreenId */);
|
|
|
|
}
|
|
|
|
|
2022-07-20 02:09:14 -06:00
|
|
|
// Handles requests for legacy-style `navigator.getUserMedia(...)` calls.
|
|
|
|
// This includes desktop capture through the chromeMediaSource /
|
|
|
|
// chromeMediaSourceId constraints.
|
|
|
|
void HandleUserMediaRequest(const content::MediaStreamRequest& request,
|
|
|
|
content::MediaResponseCallback callback) {
|
|
|
|
blink::mojom::StreamDevicesSetPtr stream_devices_set =
|
|
|
|
blink::mojom::StreamDevicesSet::New();
|
|
|
|
stream_devices_set->stream_devices.emplace_back(
|
|
|
|
blink::mojom::StreamDevices::New());
|
|
|
|
blink::mojom::StreamDevices& devices = *stream_devices_set->stream_devices[0];
|
|
|
|
|
|
|
|
if (request.audio_type ==
|
|
|
|
blink::mojom::MediaStreamType::GUM_TAB_AUDIO_CAPTURE) {
|
|
|
|
devices.audio_device = blink::MediaStreamDevice(
|
|
|
|
blink::mojom::MediaStreamType::GUM_TAB_AUDIO_CAPTURE, "", "");
|
|
|
|
}
|
|
|
|
if (request.video_type ==
|
|
|
|
blink::mojom::MediaStreamType::GUM_TAB_VIDEO_CAPTURE) {
|
|
|
|
devices.video_device = blink::MediaStreamDevice(
|
|
|
|
blink::mojom::MediaStreamType::GUM_TAB_VIDEO_CAPTURE, "", "");
|
|
|
|
}
|
|
|
|
if (request.audio_type ==
|
|
|
|
blink::mojom::MediaStreamType::GUM_DESKTOP_AUDIO_CAPTURE) {
|
|
|
|
devices.audio_device = blink::MediaStreamDevice(
|
|
|
|
blink::mojom::MediaStreamType::GUM_DESKTOP_AUDIO_CAPTURE, "loopback",
|
|
|
|
"System Audio");
|
|
|
|
}
|
|
|
|
if (request.video_type ==
|
|
|
|
blink::mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE) {
|
|
|
|
devices.video_device = blink::MediaStreamDevice(
|
|
|
|
blink::mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE,
|
2024-02-14 10:33:32 -07:00
|
|
|
GetScreenId(request.requested_video_device_ids).ToString(), "Screen");
|
2022-07-20 02:09:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
bool empty =
|
|
|
|
!devices.audio_device.has_value() && !devices.video_device.has_value();
|
|
|
|
std::move(callback).Run(
|
|
|
|
*stream_devices_set,
|
|
|
|
empty ? blink::mojom::MediaStreamRequestResult::NO_HARDWARE
|
|
|
|
: blink::mojom::MediaStreamRequestResult::OK,
|
|
|
|
nullptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void OnMediaStreamRequestResponse(
|
|
|
|
content::MediaResponseCallback callback,
|
|
|
|
const blink::mojom::StreamDevicesSet& stream_devices_set,
|
|
|
|
blink::mojom::MediaStreamRequestResult result,
|
|
|
|
bool blocked_by_permissions_policy,
|
|
|
|
ContentSetting audio_setting,
|
|
|
|
ContentSetting video_setting) {
|
|
|
|
std::move(callback).Run(stream_devices_set, result, nullptr);
|
|
|
|
}
|
|
|
|
|
2018-04-17 19:55:30 -06:00
|
|
|
void MediaAccessAllowed(const content::MediaStreamRequest& request,
|
2018-10-02 12:09:25 -06:00
|
|
|
content::MediaResponseCallback callback,
|
2018-04-17 19:55:30 -06:00
|
|
|
bool allowed) {
|
2022-07-20 02:09:14 -06:00
|
|
|
if (allowed) {
|
|
|
|
if (request.video_type ==
|
|
|
|
blink::mojom::MediaStreamType::GUM_DESKTOP_VIDEO_CAPTURE ||
|
|
|
|
request.audio_type ==
|
|
|
|
blink::mojom::MediaStreamType::GUM_DESKTOP_AUDIO_CAPTURE ||
|
|
|
|
request.video_type ==
|
|
|
|
blink::mojom::MediaStreamType::GUM_TAB_VIDEO_CAPTURE ||
|
|
|
|
request.audio_type ==
|
2022-08-22 15:15:32 -06:00
|
|
|
blink::mojom::MediaStreamType::GUM_TAB_AUDIO_CAPTURE) {
|
2022-07-20 02:09:14 -06:00
|
|
|
HandleUserMediaRequest(request, std::move(callback));
|
2022-08-22 15:15:32 -06:00
|
|
|
} else if (request.video_type ==
|
|
|
|
blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE ||
|
|
|
|
request.audio_type ==
|
|
|
|
blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE) {
|
2022-07-20 02:09:14 -06:00
|
|
|
webrtc::MediaStreamDevicesController::RequestPermissions(
|
|
|
|
request, MediaCaptureDevicesDispatcher::GetInstance(),
|
2023-01-11 03:55:31 -07:00
|
|
|
base::BindOnce(&OnMediaStreamRequestResponse, std::move(callback)),
|
|
|
|
allowed);
|
2022-08-22 15:15:32 -06:00
|
|
|
} else if (request.video_type ==
|
|
|
|
blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE ||
|
|
|
|
request.video_type == blink::mojom::MediaStreamType::
|
|
|
|
DISPLAY_VIDEO_CAPTURE_THIS_TAB ||
|
|
|
|
request.video_type ==
|
|
|
|
blink::mojom::MediaStreamType::DISPLAY_VIDEO_CAPTURE_SET ||
|
|
|
|
request.audio_type ==
|
|
|
|
blink::mojom::MediaStreamType::DISPLAY_AUDIO_CAPTURE) {
|
|
|
|
content::RenderFrameHost* rfh = content::RenderFrameHost::FromID(
|
|
|
|
request.render_process_id, request.render_frame_id);
|
|
|
|
if (!rfh)
|
|
|
|
return;
|
|
|
|
|
|
|
|
content::BrowserContext* browser_context = rfh->GetBrowserContext();
|
|
|
|
ElectronBrowserContext* electron_browser_context =
|
|
|
|
static_cast<ElectronBrowserContext*>(browser_context);
|
|
|
|
auto split_callback = base::SplitOnceCallback(std::move(callback));
|
|
|
|
if (electron_browser_context->ChooseDisplayMediaDevice(
|
|
|
|
request, std::move(split_callback.second)))
|
|
|
|
return;
|
|
|
|
std::move(split_callback.first)
|
|
|
|
.Run(blink::mojom::StreamDevicesSet(),
|
|
|
|
blink::mojom::MediaStreamRequestResult::NOT_SUPPORTED, nullptr);
|
|
|
|
} else {
|
2022-07-20 02:09:14 -06:00
|
|
|
std::move(callback).Run(
|
|
|
|
blink::mojom::StreamDevicesSet(),
|
|
|
|
blink::mojom::MediaStreamRequestResult::NOT_SUPPORTED, nullptr);
|
2022-08-22 15:15:32 -06:00
|
|
|
}
|
2022-07-20 02:09:14 -06:00
|
|
|
} else {
|
|
|
|
std::move(callback).Run(
|
|
|
|
blink::mojom::StreamDevicesSet(),
|
|
|
|
blink::mojom::MediaStreamRequestResult::PERMISSION_DENIED, nullptr);
|
|
|
|
}
|
2016-01-23 06:29:47 -07:00
|
|
|
}
|
|
|
|
|
2019-05-29 14:02:15 -06:00
|
|
|
void OnPermissionResponse(base::OnceCallback<void(bool)> callback,
|
2016-05-22 21:28:59 -06:00
|
|
|
blink::mojom::PermissionStatus status) {
|
|
|
|
if (status == blink::mojom::PermissionStatus::GRANTED)
|
2019-05-29 14:02:15 -06:00
|
|
|
std::move(callback).Run(true);
|
2016-01-31 14:35:34 -07:00
|
|
|
else
|
2019-05-29 14:02:15 -06:00
|
|
|
std::move(callback).Run(false);
|
2016-01-31 14:35:34 -07:00
|
|
|
}
|
|
|
|
|
2016-01-23 06:29:47 -07:00
|
|
|
} // namespace
|
|
|
|
|
|
|
|
WebContentsPermissionHelper::WebContentsPermissionHelper(
|
2016-01-30 04:19:18 -07:00
|
|
|
content::WebContents* web_contents)
|
2022-01-10 15:31:39 -07:00
|
|
|
: content::WebContentsUserData<WebContentsPermissionHelper>(*web_contents),
|
|
|
|
web_contents_(web_contents) {}
|
2016-01-23 06:29:47 -07:00
|
|
|
|
2019-09-16 16:12:00 -06:00
|
|
|
WebContentsPermissionHelper::~WebContentsPermissionHelper() = default;
|
2016-01-23 06:29:47 -07:00
|
|
|
|
2016-01-30 04:19:18 -07:00
|
|
|
void WebContentsPermissionHelper::RequestPermission(
|
2022-08-26 04:31:33 -06:00
|
|
|
content::RenderFrameHost* requesting_frame,
|
2022-05-17 10:48:40 -06:00
|
|
|
blink::PermissionType permission,
|
2019-05-29 14:02:15 -06:00
|
|
|
base::OnceCallback<void(bool)> callback,
|
2017-11-10 20:27:30 -07:00
|
|
|
bool user_gesture,
|
2022-06-29 11:09:48 -06:00
|
|
|
base::Value::Dict details) {
|
2020-02-04 13:19:40 -07:00
|
|
|
auto* permission_manager = static_cast<ElectronPermissionManager*>(
|
2018-10-02 15:53:10 -06:00
|
|
|
web_contents_->GetBrowserContext()->GetPermissionControllerDelegate());
|
2016-01-30 04:19:18 -07:00
|
|
|
auto origin = web_contents_->GetLastCommittedURL();
|
2017-11-10 20:27:30 -07:00
|
|
|
permission_manager->RequestPermissionWithDetails(
|
2022-08-26 04:31:33 -06:00
|
|
|
permission, requesting_frame, origin, false, std::move(details),
|
2019-05-29 14:02:15 -06:00
|
|
|
base::BindOnce(&OnPermissionResponse, std::move(callback)));
|
2016-01-30 04:19:18 -07:00
|
|
|
}
|
|
|
|
|
2018-08-28 08:05:08 -06:00
|
|
|
bool WebContentsPermissionHelper::CheckPermission(
|
2022-05-17 10:48:40 -06:00
|
|
|
blink::PermissionType permission,
|
2022-06-29 11:09:48 -06:00
|
|
|
base::Value::Dict details) const {
|
2022-06-27 14:50:08 -06:00
|
|
|
auto* rfh = web_contents_->GetPrimaryMainFrame();
|
2020-02-04 13:19:40 -07:00
|
|
|
auto* permission_manager = static_cast<ElectronPermissionManager*>(
|
2018-10-02 15:53:10 -06:00
|
|
|
web_contents_->GetBrowserContext()->GetPermissionControllerDelegate());
|
2018-08-28 08:05:08 -06:00
|
|
|
auto origin = web_contents_->GetLastCommittedURL();
|
|
|
|
return permission_manager->CheckPermissionWithDetails(permission, rfh, origin,
|
2022-06-29 11:09:48 -06:00
|
|
|
std::move(details));
|
2018-08-28 08:05:08 -06:00
|
|
|
}
|
|
|
|
|
2016-02-01 03:03:38 -07:00
|
|
|
void WebContentsPermissionHelper::RequestFullscreenPermission(
|
2022-08-26 04:31:33 -06:00
|
|
|
content::RenderFrameHost* requesting_frame,
|
2019-05-29 14:02:15 -06:00
|
|
|
base::OnceCallback<void(bool)> callback) {
|
2017-03-31 12:09:13 -06:00
|
|
|
RequestPermission(
|
2022-08-26 04:31:33 -06:00
|
|
|
requesting_frame,
|
2022-05-17 10:48:40 -06:00
|
|
|
static_cast<blink::PermissionType>(PermissionType::FULLSCREEN),
|
2019-05-29 14:02:15 -06:00
|
|
|
std::move(callback));
|
2016-02-01 03:03:38 -07:00
|
|
|
}
|
|
|
|
|
2016-01-23 06:29:47 -07:00
|
|
|
void WebContentsPermissionHelper::RequestMediaAccessPermission(
|
|
|
|
const content::MediaStreamRequest& request,
|
2018-10-02 12:09:25 -06:00
|
|
|
content::MediaResponseCallback response_callback) {
|
2021-06-16 16:43:51 -06:00
|
|
|
auto callback = base::BindOnce(&MediaAccessAllowed, request,
|
|
|
|
std::move(response_callback));
|
2018-09-12 19:57:23 -06:00
|
|
|
|
2022-06-29 11:09:48 -06:00
|
|
|
base::Value::Dict details;
|
|
|
|
base::Value::List media_types;
|
2018-09-19 05:10:26 -06:00
|
|
|
if (request.audio_type ==
|
2019-07-02 19:22:09 -06:00
|
|
|
blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE) {
|
2022-06-29 11:09:48 -06:00
|
|
|
media_types.Append("audio");
|
2018-09-12 19:57:23 -06:00
|
|
|
}
|
2018-09-19 05:10:26 -06:00
|
|
|
if (request.video_type ==
|
2019-07-02 19:22:09 -06:00
|
|
|
blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE) {
|
2022-06-29 11:09:48 -06:00
|
|
|
media_types.Append("video");
|
2018-09-12 19:57:23 -06:00
|
|
|
}
|
2022-06-29 11:09:48 -06:00
|
|
|
details.Set("mediaTypes", std::move(media_types));
|
|
|
|
details.Set("securityOrigin", request.security_origin.spec());
|
2018-09-12 19:57:23 -06:00
|
|
|
|
2016-01-31 14:35:34 -07:00
|
|
|
// The permission type doesn't matter here, AUDIO_CAPTURE/VIDEO_CAPTURE
|
|
|
|
// are presented as same type in content_converter.h.
|
2022-08-26 04:31:33 -06:00
|
|
|
RequestPermission(content::RenderFrameHost::FromID(request.render_process_id,
|
|
|
|
request.render_frame_id),
|
|
|
|
blink::PermissionType::AUDIO_CAPTURE, std::move(callback),
|
2022-06-29 11:09:48 -06:00
|
|
|
false, std::move(details));
|
2016-01-23 06:29:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
void WebContentsPermissionHelper::RequestWebNotificationPermission(
|
2022-08-26 04:31:33 -06:00
|
|
|
content::RenderFrameHost* requesting_frame,
|
2019-05-29 14:02:15 -06:00
|
|
|
base::OnceCallback<void(bool)> callback) {
|
2022-08-26 04:31:33 -06:00
|
|
|
RequestPermission(requesting_frame, blink::PermissionType::NOTIFICATIONS,
|
|
|
|
std::move(callback));
|
2016-01-23 06:29:47 -07:00
|
|
|
}
|
|
|
|
|
2016-02-01 02:43:49 -07:00
|
|
|
void WebContentsPermissionHelper::RequestPointerLockPermission(
|
2022-02-09 02:40:50 -07:00
|
|
|
bool user_gesture,
|
|
|
|
bool last_unlocked_by_target,
|
|
|
|
base::OnceCallback<void(content::WebContents*, bool, bool, bool)>
|
|
|
|
callback) {
|
2024-03-13 02:44:49 -06:00
|
|
|
RequestPermission(web_contents_->GetPrimaryMainFrame(),
|
|
|
|
blink::PermissionType::POINTER_LOCK,
|
|
|
|
base::BindOnce(std::move(callback), web_contents_,
|
|
|
|
user_gesture, last_unlocked_by_target),
|
|
|
|
user_gesture);
|
2016-02-01 02:43:49 -07:00
|
|
|
}
|
|
|
|
|
2023-11-06 12:54:31 -07:00
|
|
|
void WebContentsPermissionHelper::RequestKeyboardLockPermission(
|
|
|
|
bool esc_key_locked,
|
|
|
|
base::OnceCallback<void(content::WebContents*, bool, bool)> callback) {
|
|
|
|
RequestPermission(
|
|
|
|
web_contents_->GetPrimaryMainFrame(),
|
2024-03-13 02:44:49 -06:00
|
|
|
blink::PermissionType::KEYBOARD_LOCK,
|
2023-11-06 12:54:31 -07:00
|
|
|
base::BindOnce(std::move(callback), web_contents_, esc_key_locked));
|
|
|
|
}
|
|
|
|
|
2016-04-20 10:55:15 -06:00
|
|
|
void WebContentsPermissionHelper::RequestOpenExternalPermission(
|
2022-08-26 04:31:33 -06:00
|
|
|
content::RenderFrameHost* requesting_frame,
|
2019-05-29 14:02:15 -06:00
|
|
|
base::OnceCallback<void(bool)> callback,
|
2017-11-10 20:27:30 -07:00
|
|
|
bool user_gesture,
|
|
|
|
const GURL& url) {
|
2022-06-29 11:09:48 -06:00
|
|
|
base::Value::Dict details;
|
|
|
|
details.Set("externalURL", url.spec());
|
2017-12-19 18:49:49 -07:00
|
|
|
RequestPermission(
|
2022-08-26 04:31:33 -06:00
|
|
|
requesting_frame,
|
2022-05-17 10:48:40 -06:00
|
|
|
static_cast<blink::PermissionType>(PermissionType::OPEN_EXTERNAL),
|
2022-06-29 11:09:48 -06:00
|
|
|
std::move(callback), user_gesture, std::move(details));
|
2016-04-20 10:55:15 -06:00
|
|
|
}
|
|
|
|
|
2018-08-28 08:05:08 -06:00
|
|
|
bool WebContentsPermissionHelper::CheckMediaAccessPermission(
|
2023-11-28 14:40:12 -07:00
|
|
|
const url::Origin& security_origin,
|
2019-07-02 19:22:09 -06:00
|
|
|
blink::mojom::MediaStreamType type) const {
|
2022-06-29 11:09:48 -06:00
|
|
|
base::Value::Dict details;
|
2023-11-28 14:40:12 -07:00
|
|
|
details.Set("securityOrigin", security_origin.GetURL().spec());
|
2022-06-29 11:09:48 -06:00
|
|
|
details.Set("mediaType", MediaStreamTypeToString(type));
|
2018-08-28 08:05:08 -06:00
|
|
|
// The permission type doesn't matter here, AUDIO_CAPTURE/VIDEO_CAPTURE
|
|
|
|
// are presented as same type in content_converter.h.
|
2022-06-29 11:09:48 -06:00
|
|
|
return CheckPermission(blink::PermissionType::AUDIO_CAPTURE,
|
|
|
|
std::move(details));
|
2018-08-28 08:05:08 -06:00
|
|
|
}
|
|
|
|
|
2020-09-28 10:22:03 -06:00
|
|
|
bool WebContentsPermissionHelper::CheckSerialAccessPermission(
|
|
|
|
const url::Origin& embedding_origin) const {
|
2022-06-29 11:09:48 -06:00
|
|
|
base::Value::Dict details;
|
|
|
|
details.Set("securityOrigin", embedding_origin.GetURL().spec());
|
2020-09-28 10:22:03 -06:00
|
|
|
return CheckPermission(
|
2022-06-29 11:09:48 -06:00
|
|
|
static_cast<blink::PermissionType>(PermissionType::SERIAL),
|
|
|
|
std::move(details));
|
2020-09-28 10:22:03 -06:00
|
|
|
}
|
|
|
|
|
2021-10-21 12:51:36 -06:00
|
|
|
WEB_CONTENTS_USER_DATA_KEY_IMPL(WebContentsPermissionHelper);
|
2019-01-21 09:56:54 -07:00
|
|
|
|
2019-06-19 15:23:04 -06:00
|
|
|
} // namespace electron
|