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

Move MediaStream Mojo and public interfaces to Blink.

Browse source 
1389998
This commit is contained in:
deepak1556 2019-01-21 21:58:04 +05:30
parent 92cfc4a62d
commit a864167d46
8 changed files with 100 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

87
atom/browser/media/media_stream_devices_controller.cc
View file

@ -9,16 +9,16 @@
#include "atom/browser/media/media_capture_devices_dispatcher.h"
#include "content/public/browser/desktop_media_id.h"
#include "content/public/common/media_stream_request.h"
#include "content/public/browser/media_stream_request.h"
namespace atom {
namespace {
bool HasAnyAvailableDevice() {
const content::MediaStreamDevices& audio_devices =
const blink::MediaStreamDevices& audio_devices =
MediaCaptureDevicesDispatcher::GetInstance()->GetAudioCaptureDevices();
const content::MediaStreamDevices& video_devices =
const blink::MediaStreamDevices& video_devices =
MediaCaptureDevicesDispatcher::GetInstance()->GetVideoCaptureDevices();
return !audio_devices.empty() || !video_devices.empty();
@ -34,33 +34,33 @@ MediaStreamDevicesController::MediaStreamDevicesController(
// For MEDIA_OPEN_DEVICE requests (Pepper) we always request both webcam
// and microphone to avoid popping two infobars.
microphone_requested_(
request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
request.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY),
request.audio_type == blink::MEDIA_DEVICE_AUDIO_CAPTURE ||
request.request_type == blink::MEDIA_OPEN_DEVICE_PEPPER_ONLY),
webcam_requested_(
request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE ||
request.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY) {}
request.video_type == blink::MEDIA_DEVICE_VIDEO_CAPTURE ||
request.request_type == blink::MEDIA_OPEN_DEVICE_PEPPER_ONLY) {}
MediaStreamDevicesController::~MediaStreamDevicesController() {
if (!callback_.is_null()) {
std::move(callback_).Run(content::MediaStreamDevices(),
content::MEDIA_DEVICE_INVALID_STATE,
std::move(callback_).Run(blink::MediaStreamDevices(),
blink::MEDIA_DEVICE_FAILED_DUE_TO_SHUTDOWN,
std::unique_ptr<content::MediaStreamUI>());
}
}
bool MediaStreamDevicesController::TakeAction() {
// Do special handling of desktop screen cast.
if (request_.audio_type == content::MEDIA_GUM_TAB_AUDIO_CAPTURE ||
request_.video_type == content::MEDIA_GUM_TAB_VIDEO_CAPTURE ||
request_.audio_type == content::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE ||
request_.video_type == content::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE) {
if (request_.audio_type == blink::MEDIA_GUM_TAB_AUDIO_CAPTURE ||
request_.video_type == blink::MEDIA_GUM_TAB_VIDEO_CAPTURE ||
request_.audio_type == blink::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE ||
request_.video_type == blink::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE) {
HandleUserMediaRequest();
return true;
}
// Deny the request if there is no device attached to the OS.
if (!HasAnyAvailableDevice()) {
Deny(content::MEDIA_DEVICE_NO_HARDWARE);
Deny(blink::MEDIA_DEVICE_NO_HARDWARE);
return true;
}
@ -70,14 +70,14 @@ bool MediaStreamDevicesController::TakeAction() {
void MediaStreamDevicesController::Accept() {
// Get the default devices for the request.
content::MediaStreamDevices devices;
blink::MediaStreamDevices devices;
if (microphone_requested_ || webcam_requested_) {
switch (request_.request_type) {
case content::MEDIA_OPEN_DEVICE_PEPPER_ONLY: {
const content::MediaStreamDevice* device = nullptr;
case blink::MEDIA_OPEN_DEVICE_PEPPER_ONLY: {
const blink::MediaStreamDevice* device = nullptr;
// For open device request pick the desired device or fall back to the
// first available of the given type.
if (request_.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE) {
if (request_.audio_type == blink::MEDIA_DEVICE_AUDIO_CAPTURE) {
device =
MediaCaptureDevicesDispatcher::GetInstance()
->GetRequestedAudioDevice(request_.requested_audio_device_id);
@ -86,7 +86,7 @@ void MediaStreamDevicesController::Accept() {
device = MediaCaptureDevicesDispatcher::GetInstance()
->GetFirstAvailableAudioDevice();
}
} else if (request_.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE) {
} else if (request_.video_type == blink::MEDIA_DEVICE_VIDEO_CAPTURE) {
// Pepper API opens only one device at a time.
device =
MediaCaptureDevicesDispatcher::GetInstance()
@ -101,13 +101,13 @@ void MediaStreamDevicesController::Accept() {
devices.push_back(*device);
break;
}
case content::MEDIA_GENERATE_STREAM: {
case blink::MEDIA_GENERATE_STREAM: {
bool needs_audio_device = microphone_requested_;
bool needs_video_device = webcam_requested_;
// Get the exact audio or video device if an id is specified.
if (!request_.requested_audio_device_id.empty()) {
const content::MediaStreamDevice* audio_device =
const blink::MediaStreamDevice* audio_device =
MediaCaptureDevicesDispatcher::GetInstance()
->GetRequestedAudioDevice(request_.requested_audio_device_id);
if (audio_device) {
@ -116,7 +116,7 @@ void MediaStreamDevicesController::Accept() {
}
}
if (!request_.requested_video_device_id.empty()) {
const content::MediaStreamDevice* video_device =
const blink::MediaStreamDevice* video_device =
MediaCaptureDevicesDispatcher::GetInstance()
->GetRequestedVideoDevice(request_.requested_video_device_id);
if (video_device) {
@ -133,40 +133,45 @@ void MediaStreamDevicesController::Accept() {
}
break;
}
case content::MEDIA_DEVICE_ACCESS:
case blink::MEDIA_DEVICE_ACCESS: {
// Get the default devices for the request.
MediaCaptureDevicesDispatcher::GetInstance()->GetDefaultDevices(
microphone_requested_, webcam_requested_, &devices);
break;
}
case blink::MEDIA_DEVICE_UPDATE: {
NOTREACHED();
break;
}
}
}
std::move(callback_).Run(devices, content::MEDIA_DEVICE_OK,
std::move(callback_).Run(devices, blink::MEDIA_DEVICE_OK,
std::unique_ptr<content::MediaStreamUI>());
}
void MediaStreamDevicesController::Deny(
content::MediaStreamRequestResult result) {
std::move(callback_).Run(content::MediaStreamDevices(), result,
blink::MediaStreamRequestResult result) {
std::move(callback_).Run(blink::MediaStreamDevices(), result,
std::unique_ptr<content::MediaStreamUI>());
}
void MediaStreamDevicesController::HandleUserMediaRequest() {
content::MediaStreamDevices devices;
blink::MediaStreamDevices devices;
if (request_.audio_type == content::MEDIA_GUM_TAB_AUDIO_CAPTURE) {
devices.push_back(content::MediaStreamDevice(
content::MEDIA_GUM_TAB_AUDIO_CAPTURE, "", ""));
if (request_.audio_type == blink::MEDIA_GUM_TAB_AUDIO_CAPTURE) {
devices.push_back(
blink::MediaStreamDevice(blink::MEDIA_GUM_TAB_AUDIO_CAPTURE, "", ""));
}
if (request_.video_type == content::MEDIA_GUM_TAB_VIDEO_CAPTURE) {
devices.push_back(content::MediaStreamDevice(
content::MEDIA_GUM_TAB_VIDEO_CAPTURE, "", ""));
if (request_.video_type == blink::MEDIA_GUM_TAB_VIDEO_CAPTURE) {
devices.push_back(
blink::MediaStreamDevice(blink::MEDIA_GUM_TAB_VIDEO_CAPTURE, "", ""));
}
if (request_.audio_type == content::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE) {
devices.push_back(content::MediaStreamDevice(
content::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE, "loopback", "System Audio"));
if (request_.audio_type == blink::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE) {
devices.push_back(blink::MediaStreamDevice(
blink::MEDIA_GUM_DESKTOP_AUDIO_CAPTURE, "loopback", "System Audio"));
}
if (request_.video_type == content::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE) {
if (request_.video_type == blink::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE) {
content::DesktopMediaID screen_id;
// 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).
@ -179,13 +184,13 @@ void MediaStreamDevicesController::HandleUserMediaRequest() {
}
devices.push_back(
content::MediaStreamDevice(content::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE,
screen_id.ToString(), "Screen"));
blink::MediaStreamDevice(blink::MEDIA_GUM_DESKTOP_VIDEO_CAPTURE,
screen_id.ToString(), "Screen"));
}
std::move(callback_).Run(devices,
devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE
: content::MEDIA_DEVICE_OK,
devices.empty() ? blink::MEDIA_DEVICE_NO_HARDWARE
: blink::MEDIA_DEVICE_OK,
std::unique_ptr<content::MediaStreamUI>());
}