#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif
#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-blink.h"
#include <math.h>
#include <stdint.h>
#include <utility>
#include "base/debug/alias.h"
#include "base/hash/md5_constexpr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/features.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"
#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-params-data.h"
#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-shared-message-ids.h"
#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-blink-import-headers.h"
#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"
namespace blink::mojom::blink {
SearchOnlyByDeviceId::SearchOnlyByDeviceId() { … }
SearchOnlyByDeviceId::~SearchOnlyByDeviceId() = default;
size_t SearchOnlyByDeviceId::Hash(size_t seed) const { … }
void SearchOnlyByDeviceId::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool SearchOnlyByDeviceId::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
SearchBySessionId::SearchBySessionId()
: … { … }
SearchBySessionId::SearchBySessionId(
const WTF::HashMap<WTF::String, ::base::UnguessableToken>& session_id_map_in)
: … { … }
SearchBySessionId::~SearchBySessionId() = default;
void SearchBySessionId::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool SearchBySessionId::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
MediaStreamDevice::MediaStreamDevice()
: … { … }
MediaStreamDevice::MediaStreamDevice(
MediaStreamType type_in,
const WTF::String& id_in,
int64_t display_id_in,
::media::VideoFacingMode video_facing_in,
const WTF::String& group_id_in,
const WTF::String& matched_output_device_id_in,
const WTF::String& name_in,
const ::media::AudioParameters& input_in,
const std::optional<::base::UnguessableToken>& session_id_in,
::media::mojom::blink::DisplayMediaInformationPtr display_media_info_in)
: … { … }
MediaStreamDevice::~MediaStreamDevice() = default;
void MediaStreamDevice::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool MediaStreamDevice::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
TrackControls::TrackControls()
: … { … }
TrackControls::TrackControls(
MediaStreamType stream_type_in,
WTF::Vector<WTF::String> device_ids_in)
: … { … }
TrackControls::~TrackControls() = default;
void TrackControls::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool TrackControls::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
StreamControls::StreamControls()
: … { … }
StreamControls::StreamControls(
const ::blink::TrackControls& audio_in,
const ::blink::TrackControls& video_in,
bool hotword_enabled_in,
bool disable_local_echo_in,
bool suppress_local_audio_playback_in,
bool exclude_system_audio_in,
bool exclude_self_browser_surface_in,
bool request_pan_tilt_zoom_permission_in,
bool request_all_screens_in,
PreferredDisplaySurface preferred_display_surface_in,
bool dynamic_surface_switching_requested_in,
bool exclude_monitor_type_surfaces_in)
: … { … }
StreamControls::~StreamControls() = default;
void StreamControls::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool StreamControls::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
GetOpenDeviceResponse::GetOpenDeviceResponse()
: … { … }
GetOpenDeviceResponse::GetOpenDeviceResponse(
const WTF::String& label_in,
const ::blink::MediaStreamDevice& device_in,
bool pan_tilt_zoom_allowed_in)
: … { … }
GetOpenDeviceResponse::~GetOpenDeviceResponse() = default;
void GetOpenDeviceResponse::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool GetOpenDeviceResponse::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
CapturedWheelAction::CapturedWheelAction()
: … { … }
CapturedWheelAction::CapturedWheelAction(
double relative_x_in,
double relative_y_in,
int32_t wheel_delta_x_in,
int32_t wheel_delta_y_in)
: … { … }
CapturedWheelAction::~CapturedWheelAction() = default;
size_t CapturedWheelAction::Hash(size_t seed) const { … }
void CapturedWheelAction::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool CapturedWheelAction::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
StreamDevices::StreamDevices()
: … { … }
StreamDevices::StreamDevices(
const std::optional<::blink::MediaStreamDevice>& audio_device_in,
const std::optional<::blink::MediaStreamDevice>& video_device_in)
: … { … }
StreamDevices::~StreamDevices() = default;
void StreamDevices::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool StreamDevices::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
StreamDevicesSet::StreamDevicesSet()
: … { … }
StreamDevicesSet::StreamDevicesSet(
WTF::Vector<StreamDevicesPtr> stream_devices_in)
: … { … }
StreamDevicesSet::~StreamDevicesSet() = default;
void StreamDevicesSet::WriteIntoTrace(
perfetto::TracedValue traced_context) const { … }
bool StreamDevicesSet::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
StreamSelectionInfo::StreamSelectionInfo() : … { … }
StreamSelectionInfo::~StreamSelectionInfo() { … }
void StreamSelectionInfo::set_search_only_by_device_id(
SearchOnlyByDeviceIdPtr search_only_by_device_id) { … }
void StreamSelectionInfo::set_search_by_session_id(
SearchBySessionIdPtr search_by_session_id) { … }
void StreamSelectionInfo::DestroyActive() { … }
bool StreamSelectionInfo::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) { … }
const char MediaStreamDeviceObserver::Name_[] = …;
MediaStreamDeviceObserver::IPCStableHashFunction MediaStreamDeviceObserver::MessageToMethodInfo_(mojo::Message& message) { … }
const char* MediaStreamDeviceObserver::MessageToMethodName_(mojo::Message& message) { … }
#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaStreamDeviceObserver::OnDeviceStopped_Sym::IPCStableHash() { … }
uint32_t MediaStreamDeviceObserver::OnDeviceChanged_Sym::IPCStableHash() { … }
uint32_t MediaStreamDeviceObserver::OnDeviceRequestStateChange_Sym::IPCStableHash() { … }
uint32_t MediaStreamDeviceObserver::OnDeviceCaptureConfigurationChange_Sym::IPCStableHash() { … }
uint32_t MediaStreamDeviceObserver::OnDeviceCaptureHandleChange_Sym::IPCStableHash() { … }
uint32_t MediaStreamDeviceObserver::OnZoomLevelChange_Sym::IPCStableHash() { … }
# endif
MediaStreamDeviceObserverProxy::MediaStreamDeviceObserverProxy(mojo::MessageReceiverWithResponder* receiver)
: … { … }
void MediaStreamDeviceObserverProxy::OnDeviceStopped(
const WTF::String& in_label, const ::blink::MediaStreamDevice& in_device) { … }
void MediaStreamDeviceObserverProxy::OnDeviceChanged(
const WTF::String& in_label, const ::blink::MediaStreamDevice& in_old_device, const ::blink::MediaStreamDevice& in_new_device) { … }
void MediaStreamDeviceObserverProxy::OnDeviceRequestStateChange(
const WTF::String& in_label, const ::blink::MediaStreamDevice& in_device, MediaStreamStateChange in_new_state) { … }
void MediaStreamDeviceObserverProxy::OnDeviceCaptureConfigurationChange(
const WTF::String& in_label, const ::blink::MediaStreamDevice& in_device) { … }
void MediaStreamDeviceObserverProxy::OnDeviceCaptureHandleChange(
const WTF::String& in_label, const ::blink::MediaStreamDevice& in_device) { … }
void MediaStreamDeviceObserverProxy::OnZoomLevelChange(
const WTF::String& in_label, const ::blink::MediaStreamDevice& in_device, int32_t in_zoom_level) { … }
bool MediaStreamDeviceObserverStubDispatch::Accept(
MediaStreamDeviceObserver* impl,
mojo::Message* message) { … }
bool MediaStreamDeviceObserverStubDispatch::AcceptWithResponder(
MediaStreamDeviceObserver* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}
static const mojo::internal::GenericValidationInfo kMediaStreamDeviceObserverValidationInfo[] = …;
bool MediaStreamDeviceObserverRequestValidator::Accept(mojo::Message* message) { … }
const char MediaStreamDispatcherHost::Name_[] = …;
MediaStreamDispatcherHost::IPCStableHashFunction MediaStreamDispatcherHost::MessageToMethodInfo_(mojo::Message& message) { … }
const char* MediaStreamDispatcherHost::MessageToMethodName_(mojo::Message& message) { … }
#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaStreamDispatcherHost::GenerateStreams_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::FocusCapturedSurface_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::CancelRequest_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::StopStreamDevice_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::OpenDevice_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::CloseDevice_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::SetCapturingLinkSecured_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::ApplySubCaptureTarget_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::SendWheel_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::SetZoomLevel_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::RequestCapturedSurfaceControlPermission_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::GetOpenDevice_Sym::IPCStableHash() { … }
uint32_t MediaStreamDispatcherHost::KeepDeviceAliveForTransfer_Sym::IPCStableHash() { … }
# endif
bool MediaStreamDispatcherHost::GetOpenDevice(int32_t request_id, const ::base::UnguessableToken& session_id, const ::base::UnguessableToken& transfer_id, MediaStreamRequestResult* out_result, GetOpenDeviceResponsePtr* out_response) { … }
class MediaStreamDispatcherHost_GenerateStreams_ForwardToCallback
: public mojo::MessageReceiver { … };
class MediaStreamDispatcherHost_OpenDevice_ForwardToCallback
: public mojo::MessageReceiver { … };
class MediaStreamDispatcherHost_ApplySubCaptureTarget_ForwardToCallback
: public mojo::MessageReceiver { … };
class MediaStreamDispatcherHost_SendWheel_ForwardToCallback
: public mojo::MessageReceiver { … };
class MediaStreamDispatcherHost_SetZoomLevel_ForwardToCallback
: public mojo::MessageReceiver { … };
class MediaStreamDispatcherHost_RequestCapturedSurfaceControlPermission_ForwardToCallback
: public mojo::MessageReceiver { … };
class MediaStreamDispatcherHost_GetOpenDevice_HandleSyncResponse
: public mojo::MessageReceiver { … };
class MediaStreamDispatcherHost_GetOpenDevice_ForwardToCallback
: public mojo::MessageReceiver { … };
class MediaStreamDispatcherHost_KeepDeviceAliveForTransfer_ForwardToCallback
: public mojo::MessageReceiver { … };
MediaStreamDispatcherHostProxy::MediaStreamDispatcherHostProxy(mojo::MessageReceiverWithResponder* receiver)
: … { … }
void MediaStreamDispatcherHostProxy::GenerateStreams(
int32_t in_request_id, const ::blink::StreamControls& in_controls, bool in_user_gesture, StreamSelectionInfoPtr in_audio_stream_selection_info, GenerateStreamsCallback callback) { … }
void MediaStreamDispatcherHostProxy::FocusCapturedSurface(
const WTF::String& in_label, bool in_focus) { … }
void MediaStreamDispatcherHostProxy::CancelRequest(
int32_t in_request_id) { … }
void MediaStreamDispatcherHostProxy::StopStreamDevice(
const WTF::String& in_device_id, const std::optional<::base::UnguessableToken>& in_session_id) { … }
void MediaStreamDispatcherHostProxy::OpenDevice(
int32_t in_request_id, const WTF::String& in_device_id, MediaStreamType in_type, OpenDeviceCallback callback) { … }
void MediaStreamDispatcherHostProxy::CloseDevice(
const WTF::String& in_label) { … }
void MediaStreamDispatcherHostProxy::SetCapturingLinkSecured(
const std::optional<::base::UnguessableToken>& in_session_id, MediaStreamType in_type, bool in_is_secure) { … }
void MediaStreamDispatcherHostProxy::ApplySubCaptureTarget(
const ::base::UnguessableToken& in_session_id, ::media::mojom::blink::SubCaptureTargetType in_type, const ::base::Token& in_sub_capture_target, uint32_t in_sub_capture_target_version, ApplySubCaptureTargetCallback callback) { … }
void MediaStreamDispatcherHostProxy::SendWheel(
const ::base::UnguessableToken& in_session_id, CapturedWheelActionPtr in_action, SendWheelCallback callback) { … }
void MediaStreamDispatcherHostProxy::SetZoomLevel(
const ::base::UnguessableToken& in_session_id, int32_t in_zoom_level, SetZoomLevelCallback callback) { … }
void MediaStreamDispatcherHostProxy::RequestCapturedSurfaceControlPermission(
const ::base::UnguessableToken& in_session_id, RequestCapturedSurfaceControlPermissionCallback callback) { … }
bool MediaStreamDispatcherHostProxy::GetOpenDevice(
int32_t param_request_id, const ::base::UnguessableToken& param_session_id, const ::base::UnguessableToken& param_transfer_id, MediaStreamRequestResult* out_param_result, GetOpenDeviceResponsePtr* out_param_response) { … }
void MediaStreamDispatcherHostProxy::GetOpenDevice(
int32_t in_request_id, const ::base::UnguessableToken& in_session_id, const ::base::UnguessableToken& in_transfer_id, GetOpenDeviceCallback callback) { … }
void MediaStreamDispatcherHostProxy::KeepDeviceAliveForTransfer(
const ::base::UnguessableToken& in_session_id, const ::base::UnguessableToken& in_transfer_id, KeepDeviceAliveForTransferCallback callback) { … }
class MediaStreamDispatcherHost_GenerateStreams_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool MediaStreamDispatcherHost_GenerateStreams_ForwardToCallback::Accept(
mojo::Message* message) { … }
void MediaStreamDispatcherHost_GenerateStreams_ProxyToResponder::Run(
MediaStreamRequestResult in_result, const WTF::String& in_label, StreamDevicesSetPtr in_stream_devices, bool in_pan_tilt_zoom_allowed) { … }
class MediaStreamDispatcherHost_OpenDevice_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool MediaStreamDispatcherHost_OpenDevice_ForwardToCallback::Accept(
mojo::Message* message) { … }
void MediaStreamDispatcherHost_OpenDevice_ProxyToResponder::Run(
bool in_success, const WTF::String& in_label, const ::blink::MediaStreamDevice& in_device) { … }
class MediaStreamDispatcherHost_ApplySubCaptureTarget_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool MediaStreamDispatcherHost_ApplySubCaptureTarget_ForwardToCallback::Accept(
mojo::Message* message) { … }
void MediaStreamDispatcherHost_ApplySubCaptureTarget_ProxyToResponder::Run(
::media::mojom::blink::ApplySubCaptureTargetResult in_result) { … }
class MediaStreamDispatcherHost_SendWheel_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool MediaStreamDispatcherHost_SendWheel_ForwardToCallback::Accept(
mojo::Message* message) { … }
void MediaStreamDispatcherHost_SendWheel_ProxyToResponder::Run(
CapturedSurfaceControlResult in_result) { … }
class MediaStreamDispatcherHost_SetZoomLevel_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool MediaStreamDispatcherHost_SetZoomLevel_ForwardToCallback::Accept(
mojo::Message* message) { … }
void MediaStreamDispatcherHost_SetZoomLevel_ProxyToResponder::Run(
CapturedSurfaceControlResult in_result) { … }
class MediaStreamDispatcherHost_RequestCapturedSurfaceControlPermission_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool MediaStreamDispatcherHost_RequestCapturedSurfaceControlPermission_ForwardToCallback::Accept(
mojo::Message* message) { … }
void MediaStreamDispatcherHost_RequestCapturedSurfaceControlPermission_ProxyToResponder::Run(
CapturedSurfaceControlResult in_result) { … }
class MediaStreamDispatcherHost_GetOpenDevice_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool MediaStreamDispatcherHost_GetOpenDevice_ForwardToCallback::Accept(
mojo::Message* message) { … }
void MediaStreamDispatcherHost_GetOpenDevice_ProxyToResponder::Run(
MediaStreamRequestResult in_result, GetOpenDeviceResponsePtr in_response) { … }
bool MediaStreamDispatcherHost_GetOpenDevice_HandleSyncResponse::Accept(
mojo::Message* message) { … }
class MediaStreamDispatcherHost_KeepDeviceAliveForTransfer_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };
bool MediaStreamDispatcherHost_KeepDeviceAliveForTransfer_ForwardToCallback::Accept(
mojo::Message* message) { … }
void MediaStreamDispatcherHost_KeepDeviceAliveForTransfer_ProxyToResponder::Run(
bool in_device_found) { … }
bool MediaStreamDispatcherHostStubDispatch::Accept(
MediaStreamDispatcherHost* impl,
mojo::Message* message) { … }
bool MediaStreamDispatcherHostStubDispatch::AcceptWithResponder(
MediaStreamDispatcherHost* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}
static const mojo::internal::GenericValidationInfo kMediaStreamDispatcherHostValidationInfo[] = …;
bool MediaStreamDispatcherHostRequestValidator::Accept(mojo::Message* message) { … }
bool MediaStreamDispatcherHostResponseValidator::Accept(mojo::Message* message) { … }
const char MediaStreamTrackMetricsHost::Name_[] = …;
MediaStreamTrackMetricsHost::IPCStableHashFunction MediaStreamTrackMetricsHost::MessageToMethodInfo_(mojo::Message& message) { … }
const char* MediaStreamTrackMetricsHost::MessageToMethodName_(mojo::Message& message) { … }
#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaStreamTrackMetricsHost::AddTrack_Sym::IPCStableHash() { … }
uint32_t MediaStreamTrackMetricsHost::RemoveTrack_Sym::IPCStableHash() { … }
# endif
MediaStreamTrackMetricsHostProxy::MediaStreamTrackMetricsHostProxy(mojo::MessageReceiverWithResponder* receiver)
: … { … }
void MediaStreamTrackMetricsHostProxy::AddTrack(
uint64_t in_id, bool in_is_audio, bool in_is_remote) { … }
void MediaStreamTrackMetricsHostProxy::RemoveTrack(
uint64_t in_id) { … }
bool MediaStreamTrackMetricsHostStubDispatch::Accept(
MediaStreamTrackMetricsHost* impl,
mojo::Message* message) { … }
bool MediaStreamTrackMetricsHostStubDispatch::AcceptWithResponder(
MediaStreamTrackMetricsHost* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}
static const mojo::internal::GenericValidationInfo kMediaStreamTrackMetricsHostValidationInfo[] = …;
bool MediaStreamTrackMetricsHostRequestValidator::Accept(mojo::Message* message) { … }
}
namespace mojo {
bool StructTraits<::blink::mojom::blink::SearchOnlyByDeviceId::DataView, ::blink::mojom::blink::SearchOnlyByDeviceIdPtr>::Read(
::blink::mojom::blink::SearchOnlyByDeviceId::DataView input,
::blink::mojom::blink::SearchOnlyByDeviceIdPtr* output) { … }
bool StructTraits<::blink::mojom::blink::SearchBySessionId::DataView, ::blink::mojom::blink::SearchBySessionIdPtr>::Read(
::blink::mojom::blink::SearchBySessionId::DataView input,
::blink::mojom::blink::SearchBySessionIdPtr* output) { … }
bool StructTraits<::blink::mojom::blink::MediaStreamDevice::DataView, ::blink::mojom::blink::MediaStreamDevicePtr>::Read(
::blink::mojom::blink::MediaStreamDevice::DataView input,
::blink::mojom::blink::MediaStreamDevicePtr* output) { … }
bool StructTraits<::blink::mojom::blink::TrackControls::DataView, ::blink::mojom::blink::TrackControlsPtr>::Read(
::blink::mojom::blink::TrackControls::DataView input,
::blink::mojom::blink::TrackControlsPtr* output) { … }
bool StructTraits<::blink::mojom::blink::StreamControls::DataView, ::blink::mojom::blink::StreamControlsPtr>::Read(
::blink::mojom::blink::StreamControls::DataView input,
::blink::mojom::blink::StreamControlsPtr* output) { … }
bool StructTraits<::blink::mojom::blink::GetOpenDeviceResponse::DataView, ::blink::mojom::blink::GetOpenDeviceResponsePtr>::Read(
::blink::mojom::blink::GetOpenDeviceResponse::DataView input,
::blink::mojom::blink::GetOpenDeviceResponsePtr* output) { … }
bool StructTraits<::blink::mojom::blink::CapturedWheelAction::DataView, ::blink::mojom::blink::CapturedWheelActionPtr>::Read(
::blink::mojom::blink::CapturedWheelAction::DataView input,
::blink::mojom::blink::CapturedWheelActionPtr* output) { … }
bool StructTraits<::blink::mojom::blink::StreamDevices::DataView, ::blink::mojom::blink::StreamDevicesPtr>::Read(
::blink::mojom::blink::StreamDevices::DataView input,
::blink::mojom::blink::StreamDevicesPtr* output) { … }
bool StructTraits<::blink::mojom::blink::StreamDevicesSet::DataView, ::blink::mojom::blink::StreamDevicesSetPtr>::Read(
::blink::mojom::blink::StreamDevicesSet::DataView input,
::blink::mojom::blink::StreamDevicesSetPtr* output) { … }
bool UnionTraits<::blink::mojom::blink::StreamSelectionInfo::DataView, ::blink::mojom::blink::StreamSelectionInfoPtr>::Read(
::blink::mojom::blink::StreamSelectionInfo::DataView input,
::blink::mojom::blink::StreamSelectionInfoPtr* output) { … }
}
namespace blink::mojom::blink {
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceStopped(const WTF::String& label, const ::blink::MediaStreamDevice& device) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceChanged(const WTF::String& label, const ::blink::MediaStreamDevice& old_device, const ::blink::MediaStreamDevice& new_device) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceRequestStateChange(const WTF::String& label, const ::blink::MediaStreamDevice& device, MediaStreamStateChange new_state) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceCaptureConfigurationChange(const WTF::String& label, const ::blink::MediaStreamDevice& device) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceCaptureHandleChange(const WTF::String& label, const ::blink::MediaStreamDevice& device) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnZoomLevelChange(const WTF::String& label, const ::blink::MediaStreamDevice& device, int32_t zoom_level) { … }
MediaStreamDeviceObserverAsyncWaiter::MediaStreamDeviceObserverAsyncWaiter(
MediaStreamDeviceObserver* proxy) : … { … }
MediaStreamDeviceObserverAsyncWaiter::~MediaStreamDeviceObserverAsyncWaiter() = default;
void MediaStreamDispatcherHostInterceptorForTesting::GenerateStreams(int32_t request_id, const ::blink::StreamControls& controls, bool user_gesture, StreamSelectionInfoPtr audio_stream_selection_info, GenerateStreamsCallback callback) { … }
void MediaStreamDispatcherHostInterceptorForTesting::FocusCapturedSurface(const WTF::String& label, bool focus) { … }
void MediaStreamDispatcherHostInterceptorForTesting::CancelRequest(int32_t request_id) { … }
void MediaStreamDispatcherHostInterceptorForTesting::StopStreamDevice(const WTF::String& device_id, const std::optional<::base::UnguessableToken>& session_id) { … }
void MediaStreamDispatcherHostInterceptorForTesting::OpenDevice(int32_t request_id, const WTF::String& device_id, MediaStreamType type, OpenDeviceCallback callback) { … }
void MediaStreamDispatcherHostInterceptorForTesting::CloseDevice(const WTF::String& label) { … }
void MediaStreamDispatcherHostInterceptorForTesting::SetCapturingLinkSecured(const std::optional<::base::UnguessableToken>& session_id, MediaStreamType type, bool is_secure) { … }
void MediaStreamDispatcherHostInterceptorForTesting::ApplySubCaptureTarget(const ::base::UnguessableToken& session_id, ::media::mojom::blink::SubCaptureTargetType type, const ::base::Token& sub_capture_target, uint32_t sub_capture_target_version, ApplySubCaptureTargetCallback callback) { … }
void MediaStreamDispatcherHostInterceptorForTesting::SendWheel(const ::base::UnguessableToken& session_id, CapturedWheelActionPtr action, SendWheelCallback callback) { … }
void MediaStreamDispatcherHostInterceptorForTesting::SetZoomLevel(const ::base::UnguessableToken& session_id, int32_t zoom_level, SetZoomLevelCallback callback) { … }
void MediaStreamDispatcherHostInterceptorForTesting::RequestCapturedSurfaceControlPermission(const ::base::UnguessableToken& session_id, RequestCapturedSurfaceControlPermissionCallback callback) { … }
void MediaStreamDispatcherHostInterceptorForTesting::GetOpenDevice(int32_t request_id, const ::base::UnguessableToken& session_id, const ::base::UnguessableToken& transfer_id, GetOpenDeviceCallback callback) { … }
void MediaStreamDispatcherHostInterceptorForTesting::KeepDeviceAliveForTransfer(const ::base::UnguessableToken& session_id, const ::base::UnguessableToken& transfer_id, KeepDeviceAliveForTransferCallback callback) { … }
MediaStreamDispatcherHostAsyncWaiter::MediaStreamDispatcherHostAsyncWaiter(
MediaStreamDispatcherHost* proxy) : … { … }
MediaStreamDispatcherHostAsyncWaiter::~MediaStreamDispatcherHostAsyncWaiter() = default;
void MediaStreamDispatcherHostAsyncWaiter::GenerateStreams(
int32_t request_id, const ::blink::StreamControls& controls, bool user_gesture, StreamSelectionInfoPtr audio_stream_selection_info, MediaStreamRequestResult* out_result, WTF::String* out_label, StreamDevicesSetPtr* out_stream_devices, bool* out_pan_tilt_zoom_allowed) { … }
void MediaStreamDispatcherHostAsyncWaiter::OpenDevice(
int32_t request_id, const WTF::String& device_id, MediaStreamType type, bool* out_success, WTF::String* out_label, ::blink::MediaStreamDevice* out_device) { … }
void MediaStreamDispatcherHostAsyncWaiter::ApplySubCaptureTarget(
const ::base::UnguessableToken& session_id, ::media::mojom::blink::SubCaptureTargetType type, const ::base::Token& sub_capture_target, uint32_t sub_capture_target_version, ::media::mojom::blink::ApplySubCaptureTargetResult* out_result) { … }
::media::mojom::blink::ApplySubCaptureTargetResult MediaStreamDispatcherHostAsyncWaiter::ApplySubCaptureTarget(
const ::base::UnguessableToken& session_id, ::media::mojom::blink::SubCaptureTargetType type, const ::base::Token& sub_capture_target, uint32_t sub_capture_target_version) { … }
void MediaStreamDispatcherHostAsyncWaiter::SendWheel(
const ::base::UnguessableToken& session_id, CapturedWheelActionPtr action, CapturedSurfaceControlResult* out_result) { … }
CapturedSurfaceControlResult MediaStreamDispatcherHostAsyncWaiter::SendWheel(
const ::base::UnguessableToken& session_id, CapturedWheelActionPtr action) { … }
void MediaStreamDispatcherHostAsyncWaiter::SetZoomLevel(
const ::base::UnguessableToken& session_id, int32_t zoom_level, CapturedSurfaceControlResult* out_result) { … }
CapturedSurfaceControlResult MediaStreamDispatcherHostAsyncWaiter::SetZoomLevel(
const ::base::UnguessableToken& session_id, int32_t zoom_level) { … }
void MediaStreamDispatcherHostAsyncWaiter::RequestCapturedSurfaceControlPermission(
const ::base::UnguessableToken& session_id, CapturedSurfaceControlResult* out_result) { … }
CapturedSurfaceControlResult MediaStreamDispatcherHostAsyncWaiter::RequestCapturedSurfaceControlPermission(
const ::base::UnguessableToken& session_id) { … }
void MediaStreamDispatcherHostAsyncWaiter::GetOpenDevice(
int32_t request_id, const ::base::UnguessableToken& session_id, const ::base::UnguessableToken& transfer_id, MediaStreamRequestResult* out_result, GetOpenDeviceResponsePtr* out_response) { … }
void MediaStreamDispatcherHostAsyncWaiter::KeepDeviceAliveForTransfer(
const ::base::UnguessableToken& session_id, const ::base::UnguessableToken& transfer_id, bool* out_device_found) { … }
bool MediaStreamDispatcherHostAsyncWaiter::KeepDeviceAliveForTransfer(
const ::base::UnguessableToken& session_id, const ::base::UnguessableToken& transfer_id) { … }
void MediaStreamTrackMetricsHostInterceptorForTesting::AddTrack(uint64_t id, bool is_audio, bool is_remote) { … }
void MediaStreamTrackMetricsHostInterceptorForTesting::RemoveTrack(uint64_t id) { … }
MediaStreamTrackMetricsHostAsyncWaiter::MediaStreamTrackMetricsHostAsyncWaiter(
MediaStreamTrackMetricsHost* proxy) : … { … }
MediaStreamTrackMetricsHostAsyncWaiter::~MediaStreamTrackMetricsHostAsyncWaiter() = default;
}
#if defined(__clang__)
#pragma clang diagnostic pop
#endif