Skip to content

Commit

Permalink
[media] Use GlobalRenderFrameHostID in more places
Browse files Browse the repository at this point in the history 
This CL changes most of the process_id:frame_id pairs in
MediaStreamManager and MediaStreamDispatcherHost to use
GlobalRenderFrameHostID.

Change-Id: I91cb2b6e39303670a315df6231230fd28c5cf7a0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4980324
Reviewed-by: Chris Bookholt <bookholt@chromium.org>
Commit-Queue: Bryant Chandler <bryantchandler@chromium.org>
Reviewed-by: Evan Liu <evliu@google.com>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1217044}
  • Loading branch information
Bryant Chandler authored and Chromium LUCI CQ committed Oct 30, 2023
1 parent 54f41c7 commit abd520a
Show file tree
Hide file tree
Showing 9 changed files with 301 additions and 371 deletions.
116 changes: 52 additions & 64 deletions content/browser/renderer_host/media/media_stream_dispatcher_host.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,26 +47,24 @@ namespace content {
namespace {

void BindMediaStreamDeviceObserverReceiver(
int render_process_id,
int render_frame_id,
GlobalRenderFrameHostId render_frame_host_id,
mojo::PendingReceiver<blink::mojom::MediaStreamDeviceObserver> receiver) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);

RenderFrameHost* render_frame_host =
RenderFrameHost::FromID(render_process_id, render_frame_id);
RenderFrameHost::FromID(render_frame_host_id);
if (render_frame_host && render_frame_host->IsRenderFrameLive()) {
render_frame_host->GetRemoteInterfaces()->GetInterface(std::move(receiver));
}
}

std::unique_ptr<MediaStreamWebContentsObserver, BrowserThread::DeleteOnUIThread>
StartObservingWebContents(int render_process_id,
int render_frame_id,
StartObservingWebContents(GlobalRenderFrameHostId render_frame_host_id,
base::RepeatingClosure focus_callback) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);

WebContents* const web_contents = WebContents::FromRenderFrameHost(
RenderFrameHost::FromID(render_process_id, render_frame_id));
RenderFrameHost::FromID(render_frame_host_id));
std::unique_ptr<MediaStreamWebContentsObserver,
BrowserThread::DeleteOnUIThread>
web_contents_observer;
Expand Down Expand Up @@ -223,8 +221,7 @@ MediaStreamDispatcherHost::MediaStreamDispatcherHost(
int render_process_id,
int render_frame_id,
MediaStreamManager* media_stream_manager)
: render_process_id_(render_process_id),
render_frame_id_(render_frame_id),
: render_frame_host_id_(render_process_id, render_frame_id),
requester_id_(next_requester_id_++),
media_stream_manager_(media_stream_manager),
get_salt_and_origin_cb_(
Expand All @@ -237,8 +234,8 @@ MediaStreamDispatcherHost::MediaStreamDispatcherHost(
weak_factory_.GetWeakPtr());
GetUIThreadTaskRunner({})->PostTaskAndReplyWithResult(
FROM_HERE,
base::BindOnce(&StartObservingWebContents, render_process_id_,
render_frame_id_, std::move(focus_callback)),
base::BindOnce(&StartObservingWebContents, render_frame_host_id_,
std::move(focus_callback)),
base::BindOnce(&MediaStreamDispatcherHost::SetWebContentsObserver,
weak_factory_.GetWeakPtr()));
}
Expand Down Expand Up @@ -324,9 +321,9 @@ void MediaStreamDispatcherHost::OnWebContentsFocused() {
std::unique_ptr<PendingAccessRequest> request =
std::move(pending_requests_.front());
media_stream_manager_->GenerateStreams(
render_process_id_, render_frame_id_, requester_id_,
request->page_request_id, request->controls,
std::move(request->salt_and_origin), request->user_gesture,
render_frame_host_id_, requester_id_, request->page_request_id,
request->controls, std::move(request->salt_and_origin),
request->user_gesture,
std::move(request->audio_stream_selection_info_ptr),
std::move(request->callback),
base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceStopped,
Expand All @@ -347,12 +344,11 @@ void MediaStreamDispatcherHost::OnWebContentsFocused() {
}

bool MediaStreamDispatcherHost::CheckRequestAllScreensAllowed(
int render_process_id,
int render_frame_id) {
GlobalRenderFrameHostId render_frame_host_id) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);

RenderFrameHostImpl* render_frame_host =
RenderFrameHostImpl::FromID(render_process_id, render_frame_id);
RenderFrameHostImpl::FromID(render_frame_host_id);
if (!render_frame_host) {
return false;
}
Expand All @@ -363,8 +359,7 @@ bool MediaStreamDispatcherHost::CheckRequestAllScreensAllowed(
}

void MediaStreamDispatcherHost::GenerateStreamsChecksOnUIThread(
int render_process_id,
int render_frame_id,
GlobalRenderFrameHostId render_frame_host_id,
bool request_all_screens,
base::OnceCallback<void(MediaDeviceSaltAndOriginCallback)>
get_salt_and_origin_cb,
Expand All @@ -373,7 +368,7 @@ void MediaStreamDispatcherHost::GenerateStreamsChecksOnUIThread(
DCHECK_CURRENTLY_ON(BrowserThread::UI);

if (request_all_screens &&
!CheckRequestAllScreensAllowed(render_process_id, render_frame_id)) {
!CheckRequestAllScreensAllowed(render_frame_host_id)) {
std::move(result_callback)
.Run({.request_allowed = false,
.salt_and_origin = MediaDeviceSaltAndOrigin::Empty()});
Expand Down Expand Up @@ -406,8 +401,8 @@ MediaStreamDispatcherHost::GetMediaStreamDeviceObserver() {
weak_factory_.GetWeakPtr()));
GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&BindMediaStreamDeviceObserverReceiver, render_process_id_,
render_frame_id_, std::move(dispatcher_receiver)));
base::BindOnce(&BindMediaStreamDeviceObserverReceiver,
render_frame_host_id_, std::move(dispatcher_receiver)));
return media_stream_device_observer_;
}

Expand All @@ -428,7 +423,7 @@ void MediaStreamDispatcherHost::CancelAllRequests() {
/*pan_tilt_zoom_allowed=*/false);
}
pending_requests_.clear();
media_stream_manager_->CancelAllRequests(render_process_id_, render_frame_id_,
media_stream_manager_->CancelAllRequests(render_frame_host_id_,
requester_id_);
}

Expand All @@ -443,15 +438,15 @@ void MediaStreamDispatcherHost::GenerateStreams(
const absl::optional<bad_message::BadMessageReason> bad_message =
ValidateControlsForGenerateStreams(controls);
if (bad_message.has_value()) {
ReceivedBadMessage(render_process_id_, bad_message.value());
ReceivedBadMessage(render_frame_host_id_.child_id, bad_message.value());
return;
}

if (audio_stream_selection_info_ptr->strategy ==
blink::mojom::StreamSelectionStrategy::SEARCH_BY_SESSION_ID &&
(!audio_stream_selection_info_ptr->session_id.has_value() ||
audio_stream_selection_info_ptr->session_id->is_empty())) {
ReceivedBadMessage(render_process_id_,
ReceivedBadMessage(render_frame_host_id_.child_id,
bad_message::MDDH_INVALID_STREAM_SELECTION_INFO);
return;
}
Expand All @@ -460,11 +455,8 @@ void MediaStreamDispatcherHost::GenerateStreams(
FROM_HERE,
base::BindOnce(
&MediaStreamDispatcherHost::GenerateStreamsChecksOnUIThread,
/*render_process_id=*/render_process_id_,
/*render_frame_id=*/render_frame_id_, controls.request_all_screens,
base::BindOnce(
get_salt_and_origin_cb_,
GlobalRenderFrameHostId(render_process_id_, render_frame_id_)),
render_frame_host_id_, controls.request_all_screens,
base::BindOnce(get_salt_and_origin_cb_, render_frame_host_id_),
base::BindPostTaskToCurrentDefault(base::BindOnce(
&MediaStreamDispatcherHost::DoGenerateStreams,
weak_factory_.GetWeakPtr(), page_request_id, controls,
Expand Down Expand Up @@ -493,7 +485,7 @@ void MediaStreamDispatcherHost::DoGenerateStreams(
MediaDeviceSaltAndOrigin salt_and_origin =
std::move(ui_check_result.salt_and_origin);
ui_check_result = {.salt_and_origin = MediaDeviceSaltAndOrigin::Empty()};
if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
if (!MediaStreamManager::IsOriginAllowed(render_frame_host_id_.child_id,
salt_and_origin.origin())) {
std::move(callback).Run(
blink::mojom::MediaStreamRequestResult::INVALID_SECURITY_ORIGIN,
Expand Down Expand Up @@ -522,8 +514,8 @@ void MediaStreamDispatcherHost::DoGenerateStreams(
}

media_stream_manager_->GenerateStreams(
render_process_id_, render_frame_id_, requester_id_, page_request_id,
controls, std::move(salt_and_origin), user_gesture,
render_frame_host_id_, requester_id_, page_request_id, controls,
std::move(salt_and_origin), user_gesture,
std::move(audio_stream_selection_info_ptr), std::move(callback),
base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceStopped,
weak_factory_.GetWeakPtr()),
Expand All @@ -543,8 +535,8 @@ void MediaStreamDispatcherHost::DoGenerateStreams(
void MediaStreamDispatcherHost::CancelRequest(int page_request_id) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);

media_stream_manager_->CancelRequest(render_process_id_, render_frame_id_,
requester_id_, page_request_id);
media_stream_manager_->CancelRequest(render_frame_host_id_, requester_id_,
page_request_id);
}

void MediaStreamDispatcherHost::StopStreamDevice(
Expand All @@ -553,7 +545,7 @@ void MediaStreamDispatcherHost::StopStreamDevice(
DCHECK_CURRENTLY_ON(BrowserThread::IO);

media_stream_manager_->StopStreamDevice(
render_process_id_, render_frame_id_, requester_id_, device_id,
render_frame_host_id_, requester_id_, device_id,
session_id.value_or(base::UnguessableToken()));
}

Expand All @@ -566,20 +558,18 @@ void MediaStreamDispatcherHost::OpenDevice(int32_t page_request_id,
// OpenDevice is only supported for microphone or webcam capture.
if (type != blink::mojom::MediaStreamType::DEVICE_AUDIO_CAPTURE &&
type != blink::mojom::MediaStreamType::DEVICE_VIDEO_CAPTURE) {
ReceivedBadMessage(render_process_id_,
ReceivedBadMessage(render_frame_host_id_.child_id,
bad_message::MDDH_INVALID_DEVICE_TYPE_REQUEST);
return;
}

GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(
get_salt_and_origin_cb_,
GlobalRenderFrameHostId(render_process_id_, render_frame_id_),
base::BindPostTaskToCurrentDefault(
base::BindOnce(&MediaStreamDispatcherHost::DoOpenDevice,
weak_factory_.GetWeakPtr(), page_request_id,
device_id, type, std::move(callback)))));
base::BindOnce(get_salt_and_origin_cb_, render_frame_host_id_,
base::BindPostTaskToCurrentDefault(base::BindOnce(
&MediaStreamDispatcherHost::DoOpenDevice,
weak_factory_.GetWeakPtr(), page_request_id, device_id,
type, std::move(callback)))));
}

void MediaStreamDispatcherHost::DoOpenDevice(
Expand All @@ -590,16 +580,16 @@ void MediaStreamDispatcherHost::DoOpenDevice(
const MediaDeviceSaltAndOrigin& salt_and_origin) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);

if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
if (!MediaStreamManager::IsOriginAllowed(render_frame_host_id_.child_id,
salt_and_origin.origin())) {
std::move(callback).Run(false /* success */, std::string(),
blink::MediaStreamDevice());
return;
}

media_stream_manager_->OpenDevice(
render_process_id_, render_frame_id_, requester_id_, page_request_id,
device_id, type, std::move(salt_and_origin), std::move(callback),
render_frame_host_id_, requester_id_, page_request_id, device_id, type,
std::move(salt_and_origin), std::move(callback),
base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceStopped,
weak_factory_.GetWeakPtr()));
}
Expand All @@ -617,16 +607,16 @@ void MediaStreamDispatcherHost::SetCapturingLinkSecured(
DCHECK_CURRENTLY_ON(BrowserThread::IO);

media_stream_manager_->SetCapturingLinkSecured(
render_process_id_, session_id.value_or(base::UnguessableToken()), type,
is_secure);
render_frame_host_id_.child_id,
session_id.value_or(base::UnguessableToken()), type, is_secure);
}

void MediaStreamDispatcherHost::OnStreamStarted(const std::string& label) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);

if (base::FeatureList::IsEnabled(
blink::features::kStartMediaStreamCaptureIndicatorInBrowser)) {
ReceivedBadMessage(render_process_id_,
ReceivedBadMessage(render_frame_host_id_.child_id,
bad_message::MSDH_ON_STREAM_STARTED_DISALLOWED);
return;
}
Expand All @@ -640,14 +630,13 @@ void MediaStreamDispatcherHost::KeepDeviceAliveForTransfer(
DCHECK_CURRENTLY_ON(BrowserThread::IO);

if (!base::FeatureList::IsEnabled(features::kMediaStreamTrackTransfer)) {
ReceivedBadMessage(render_process_id_,
ReceivedBadMessage(render_frame_host_id_.child_id,
bad_message::MSDH_KEEP_DEVICE_ALIVE_USE_WITHOUT_FEATURE);
std::move(callback).Run(/*device_found=*/false);
return;
}
std::move(callback).Run(media_stream_manager_->KeepDeviceAliveForTransfer(
render_process_id_, render_frame_id_, requester_id_, session_id,
transfer_id));
render_frame_host_id_, requester_id_, session_id, transfer_id));
}

#if !BUILDFLAG(IS_ANDROID)
Expand Down Expand Up @@ -683,7 +672,8 @@ void MediaStreamDispatcherHost::ApplySubCaptureTarget(
GetUIThreadTaskRunner({})->PostTaskAndReplyWithResult(
FROM_HERE,
base::BindOnce(&MayApplySubCaptureTarget,
GlobalRoutingID(render_process_id_, render_frame_id_),
GlobalRoutingID(render_frame_host_id_.child_id,
render_frame_host_id_.frame_routing_id),
captured_id, type, sub_capture_target),
base::BindOnce(
&MediaStreamDispatcherHost::OnSubCaptureTargetValidationComplete,
Expand Down Expand Up @@ -729,7 +719,7 @@ void MediaStreamDispatcherHost::GetOpenDevice(
DCHECK_CURRENTLY_ON(BrowserThread::IO);

if (!base::FeatureList::IsEnabled(features::kMediaStreamTrackTransfer)) {
ReceivedBadMessage(render_process_id_,
ReceivedBadMessage(render_frame_host_id_.child_id,
bad_message::MSDH_GET_OPEN_DEVICE_USE_WITHOUT_FEATURE);

std::move(callback).Run(
Expand All @@ -744,13 +734,11 @@ void MediaStreamDispatcherHost::GetOpenDevice(

GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(
get_salt_and_origin_cb_,
GlobalRenderFrameHostId(render_process_id_, render_frame_id_),
base::BindPostTaskToCurrentDefault(
base::BindOnce(&MediaStreamDispatcherHost::DoGetOpenDevice,
weak_factory_.GetWeakPtr(), page_request_id,
session_id, transfer_id, std::move(callback)))));
base::BindOnce(get_salt_and_origin_cb_, render_frame_host_id_,
base::BindPostTaskToCurrentDefault(base::BindOnce(
&MediaStreamDispatcherHost::DoGetOpenDevice,
weak_factory_.GetWeakPtr(), page_request_id,
session_id, transfer_id, std::move(callback)))));
}

void MediaStreamDispatcherHost::DoGetOpenDevice(
Expand All @@ -760,7 +748,7 @@ void MediaStreamDispatcherHost::DoGetOpenDevice(
GetOpenDeviceCallback callback,
const MediaDeviceSaltAndOrigin& salt_and_origin) {
DCHECK_CURRENTLY_ON(BrowserThread::IO);
if (!MediaStreamManager::IsOriginAllowed(render_process_id_,
if (!MediaStreamManager::IsOriginAllowed(render_frame_host_id_.child_id,
salt_and_origin.origin())) {
std::move(callback).Run(
blink::mojom::MediaStreamRequestResult::INVALID_SECURITY_ORIGIN,
Expand All @@ -769,8 +757,8 @@ void MediaStreamDispatcherHost::DoGetOpenDevice(
}

media_stream_manager_->GetOpenDevice(
session_id, transfer_id, render_process_id_, render_frame_id_,
requester_id_, page_request_id, salt_and_origin, std::move(callback),
session_id, transfer_id, render_frame_host_id_, requester_id_,
page_request_id, salt_and_origin, std::move(callback),
base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceStopped,
weak_factory_.GetWeakPtr()),
base::BindRepeating(&MediaStreamDispatcherHost::OnDeviceChanged,
Expand Down
10 changes: 4 additions & 6 deletions content/browser/renderer_host/media/media_stream_dispatcher_host.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -83,15 +83,14 @@ class CONTENT_EXPORT MediaStreamDispatcherHost
base::circular_deque<std::unique_ptr<PendingAccessRequest>>;
RequestsQueue pending_requests_;

static bool CheckRequestAllScreensAllowed(int render_process_id,
int render_frame_id);
static bool CheckRequestAllScreensAllowed(
GlobalRenderFrameHostId render_frame_host_id);

// Performs checks / computations that need to be done on the UI
// thread (i.e. if a select all screens request is permitted and
// the computation of the device salt and origin).
static void GenerateStreamsChecksOnUIThread(
int render_process_id,
int render_frame_id,
GlobalRenderFrameHostId render_frame_host_id,
bool request_all_screens,
base::OnceCallback<void(MediaDeviceSaltAndOriginCallback)>
get_salt_and_origin_cb,
Expand Down Expand Up @@ -201,8 +200,7 @@ class CONTENT_EXPORT MediaStreamDispatcherHost

static int next_requester_id_;

const int render_process_id_;
const int render_frame_id_;
const GlobalRenderFrameHostId render_frame_host_id_;
const int requester_id_;
raw_ptr<MediaStreamManager> media_stream_manager_;
mojo::Remote<blink::mojom::MediaStreamDeviceObserver>
Expand Down

0 comments on commit abd520a

Please sign in to comment.