2016-01-23 13:29:47 +00: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.
|
|
|
|
|
|
|
|
#include "atom/browser/web_contents_permission_helper.h"
|
|
|
|
|
2018-09-13 01:57:23 +00:00
|
|
|
#include <memory>
|
2016-01-23 13:29:47 +00:00
|
|
|
#include <string>
|
2018-09-13 01:57:23 +00:00
|
|
|
#include <utility>
|
2016-01-23 13:29:47 +00:00
|
|
|
|
2016-01-30 11:19:18 +00:00
|
|
|
#include "atom/browser/atom_permission_manager.h"
|
2017-11-11 03:27:30 +00:00
|
|
|
#include "atom/common/native_mate_converters/gurl_converter.h"
|
2016-02-01 12:15:53 +00:00
|
|
|
#include "brightray/browser/media/media_stream_devices_controller.h"
|
2016-01-31 19:13:29 +00:00
|
|
|
#include "content/public/browser/browser_context.h"
|
2016-01-30 11:19:18 +00:00
|
|
|
#include "content/public/browser/render_process_host.h"
|
2016-01-23 13:29:47 +00:00
|
|
|
|
|
|
|
DEFINE_WEB_CONTENTS_USER_DATA_KEY(atom::WebContentsPermissionHelper);
|
|
|
|
|
2018-08-28 14:05:08 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
std::string MediaStreamTypeToString(content::MediaStreamType type) {
|
|
|
|
switch (type) {
|
|
|
|
case content::MediaStreamType::MEDIA_DEVICE_AUDIO_CAPTURE:
|
|
|
|
return "audio";
|
|
|
|
case content::MediaStreamType::MEDIA_DEVICE_VIDEO_CAPTURE:
|
|
|
|
return "video";
|
|
|
|
default:
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2016-01-23 13:29:47 +00:00
|
|
|
namespace atom {
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2018-04-18 01:55:30 +00:00
|
|
|
void MediaAccessAllowed(const content::MediaStreamRequest& request,
|
2018-10-02 18:09:25 +00:00
|
|
|
content::MediaResponseCallback callback,
|
2018-04-18 01:55:30 +00:00
|
|
|
bool allowed) {
|
2018-10-02 18:09:25 +00:00
|
|
|
brightray::MediaStreamDevicesController controller(request,
|
|
|
|
std::move(callback));
|
2016-02-01 12:15:53 +00:00
|
|
|
if (allowed)
|
2016-02-11 23:37:06 +00:00
|
|
|
controller.TakeAction();
|
2016-02-01 12:15:53 +00:00
|
|
|
else
|
|
|
|
controller.Deny(content::MEDIA_DEVICE_PERMISSION_DENIED);
|
2016-01-23 13:29:47 +00:00
|
|
|
}
|
|
|
|
|
2016-02-01 09:43:49 +00:00
|
|
|
void OnPointerLockResponse(content::WebContents* web_contents, bool allowed) {
|
|
|
|
if (web_contents)
|
|
|
|
web_contents->GotResponseToLockMouseRequest(allowed);
|
|
|
|
}
|
|
|
|
|
2018-10-02 18:09:25 +00:00
|
|
|
void OnPermissionResponse(base::Callback<void(bool)> callback,
|
2016-05-23 03:28:59 +00:00
|
|
|
blink::mojom::PermissionStatus status) {
|
|
|
|
if (status == blink::mojom::PermissionStatus::GRANTED)
|
2016-01-31 21:35:34 +00:00
|
|
|
callback.Run(true);
|
|
|
|
else
|
|
|
|
callback.Run(false);
|
|
|
|
}
|
|
|
|
|
2016-01-23 13:29:47 +00:00
|
|
|
} // namespace
|
|
|
|
|
|
|
|
WebContentsPermissionHelper::WebContentsPermissionHelper(
|
2016-01-30 11:19:18 +00:00
|
|
|
content::WebContents* web_contents)
|
2018-04-18 01:55:30 +00:00
|
|
|
: web_contents_(web_contents) {}
|
2016-01-23 13:29:47 +00:00
|
|
|
|
2018-04-18 01:55:30 +00:00
|
|
|
WebContentsPermissionHelper::~WebContentsPermissionHelper() {}
|
2016-01-23 13:29:47 +00:00
|
|
|
|
2016-01-30 11:19:18 +00:00
|
|
|
void WebContentsPermissionHelper::RequestPermission(
|
2017-11-11 03:27:30 +00:00
|
|
|
content::PermissionType permission,
|
|
|
|
const base::Callback<void(bool)>& callback,
|
|
|
|
bool user_gesture,
|
|
|
|
const base::DictionaryValue* details) {
|
2018-04-17 22:41:47 +00:00
|
|
|
auto* rfh = web_contents_->GetMainFrame();
|
|
|
|
auto* permission_manager = static_cast<AtomPermissionManager*>(
|
2016-01-31 19:13:29 +00:00
|
|
|
web_contents_->GetBrowserContext()->GetPermissionManager());
|
2016-01-30 11:19:18 +00:00
|
|
|
auto origin = web_contents_->GetLastCommittedURL();
|
2017-11-11 03:27:30 +00:00
|
|
|
permission_manager->RequestPermissionWithDetails(
|
2017-12-20 01:25:31 +00:00
|
|
|
permission, rfh, origin, false, details,
|
2018-10-02 18:09:25 +00:00
|
|
|
base::Bind(&OnPermissionResponse, std::move(callback)));
|
2016-01-30 11:19:18 +00:00
|
|
|
}
|
|
|
|
|
2018-08-28 14:05:08 +00:00
|
|
|
bool WebContentsPermissionHelper::CheckPermission(
|
|
|
|
content::PermissionType permission,
|
|
|
|
const base::DictionaryValue* details) const {
|
|
|
|
auto* rfh = web_contents_->GetMainFrame();
|
|
|
|
auto* permission_manager = static_cast<AtomPermissionManager*>(
|
|
|
|
web_contents_->GetBrowserContext()->GetPermissionManager());
|
|
|
|
auto origin = web_contents_->GetLastCommittedURL();
|
|
|
|
return permission_manager->CheckPermissionWithDetails(permission, rfh, origin,
|
|
|
|
details);
|
|
|
|
}
|
|
|
|
|
2016-02-01 10:03:38 +00:00
|
|
|
void WebContentsPermissionHelper::RequestFullscreenPermission(
|
|
|
|
const base::Callback<void(bool)>& callback) {
|
2017-03-31 18:09:13 +00:00
|
|
|
RequestPermission(
|
|
|
|
static_cast<content::PermissionType>(PermissionType::FULLSCREEN),
|
|
|
|
callback);
|
2016-02-01 10:03:38 +00:00
|
|
|
}
|
|
|
|
|
2016-01-23 13:29:47 +00:00
|
|
|
void WebContentsPermissionHelper::RequestMediaAccessPermission(
|
|
|
|
const content::MediaStreamRequest& request,
|
2018-10-02 18:09:25 +00:00
|
|
|
content::MediaResponseCallback response_callback) {
|
|
|
|
auto callback = base::AdaptCallbackForRepeating(base::BindOnce(
|
|
|
|
&MediaAccessAllowed, request, std::move(response_callback)));
|
2018-09-13 01:57:23 +00:00
|
|
|
|
|
|
|
base::DictionaryValue details;
|
|
|
|
std::unique_ptr<base::ListValue> media_types(new base::ListValue);
|
2018-09-19 11:10:26 +00:00
|
|
|
if (request.audio_type ==
|
|
|
|
content::MediaStreamType::MEDIA_DEVICE_AUDIO_CAPTURE) {
|
2018-09-13 01:57:23 +00:00
|
|
|
media_types->AppendString("audio");
|
|
|
|
}
|
2018-09-19 11:10:26 +00:00
|
|
|
if (request.video_type ==
|
|
|
|
content::MediaStreamType::MEDIA_DEVICE_VIDEO_CAPTURE) {
|
2018-09-13 01:57:23 +00:00
|
|
|
media_types->AppendString("video");
|
|
|
|
}
|
|
|
|
details.SetList("mediaTypes", std::move(media_types));
|
|
|
|
|
2016-01-31 21:35:34 +00:00
|
|
|
// The permission type doesn't matter here, AUDIO_CAPTURE/VIDEO_CAPTURE
|
|
|
|
// are presented as same type in content_converter.h.
|
2018-10-02 18:09:25 +00:00
|
|
|
RequestPermission(content::PermissionType::AUDIO_CAPTURE, std::move(callback),
|
|
|
|
false, &details);
|
2016-01-23 13:29:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void WebContentsPermissionHelper::RequestWebNotificationPermission(
|
2016-01-25 16:37:15 +00:00
|
|
|
const base::Callback<void(bool)>& callback) {
|
2016-01-30 11:19:18 +00:00
|
|
|
RequestPermission(content::PermissionType::NOTIFICATIONS, callback);
|
2016-01-23 13:29:47 +00:00
|
|
|
}
|
|
|
|
|
2016-02-01 09:43:49 +00:00
|
|
|
void WebContentsPermissionHelper::RequestPointerLockPermission(
|
|
|
|
bool user_gesture) {
|
2017-03-31 18:09:13 +00:00
|
|
|
RequestPermission(
|
|
|
|
static_cast<content::PermissionType>(PermissionType::POINTER_LOCK),
|
|
|
|
base::Bind(&OnPointerLockResponse, web_contents_), user_gesture);
|
2016-02-01 09:43:49 +00:00
|
|
|
}
|
|
|
|
|
2016-04-20 16:55:15 +00:00
|
|
|
void WebContentsPermissionHelper::RequestOpenExternalPermission(
|
|
|
|
const base::Callback<void(bool)>& callback,
|
2017-11-11 03:27:30 +00:00
|
|
|
bool user_gesture,
|
|
|
|
const GURL& url) {
|
|
|
|
base::DictionaryValue details;
|
2017-12-20 01:25:31 +00:00
|
|
|
details.SetString("externalURL", url.spec());
|
2017-12-20 01:49:49 +00:00
|
|
|
RequestPermission(
|
2017-03-31 18:09:13 +00:00
|
|
|
static_cast<content::PermissionType>(PermissionType::OPEN_EXTERNAL),
|
2017-11-11 03:27:30 +00:00
|
|
|
callback, user_gesture, &details);
|
2016-04-20 16:55:15 +00:00
|
|
|
}
|
|
|
|
|
2018-08-28 14:05:08 +00:00
|
|
|
bool WebContentsPermissionHelper::CheckMediaAccessPermission(
|
|
|
|
const GURL& security_origin,
|
|
|
|
content::MediaStreamType type) const {
|
|
|
|
base::DictionaryValue details;
|
|
|
|
details.SetString("securityOrigin", security_origin.spec());
|
|
|
|
details.SetString("mediaType", MediaStreamTypeToString(type));
|
|
|
|
// The permission type doesn't matter here, AUDIO_CAPTURE/VIDEO_CAPTURE
|
|
|
|
// are presented as same type in content_converter.h.
|
|
|
|
return CheckPermission(content::PermissionType::AUDIO_CAPTURE, &details);
|
|
|
|
}
|
|
|
|
|
2016-01-23 13:29:47 +00:00
|
|
|
} // namespace atom
|