media_stream.mojom.cc | Explore in Territory

// third_party/blink/public/mojom/mediastream/media_stream.mojom.cc is auto generated by mojom_bindings_generator.py, do not edit

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#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.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-import-headers.h"
#include "third_party/blink/public/mojom/mediastream/media_stream.mojom-test-utils.h"


namespace blink::mojom {
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 base::flat_map<std::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 std::string& id_in,
    int64_t display_id_in,
    ::media::VideoFacingMode video_facing_in,
    const std::optional<std::string>& group_id_in,
    const std::optional<std::string>& matched_output_device_id_in,
    const std::string& name_in,
    const ::media::AudioParameters& input_in,
    const std::optional<::base::UnguessableToken>& session_id_in,
    ::media::mojom::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,
    std::vector<std::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 std::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(
    std::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 // !BUILDFLAG(IS_FUCHSIA)

MediaStreamDeviceObserverProxy::MediaStreamDeviceObserverProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void MediaStreamDeviceObserverProxy::OnDeviceStopped(
    const std::string& in_label, const ::blink::MediaStreamDevice& in_device) { … }

void MediaStreamDeviceObserverProxy::OnDeviceChanged(
    const std::string& in_label, const ::blink::MediaStreamDevice& in_old_device, const ::blink::MediaStreamDevice& in_new_device) { … }

void MediaStreamDeviceObserverProxy::OnDeviceRequestStateChange(
    const std::string& in_label, const ::blink::MediaStreamDevice& in_device, MediaStreamStateChange in_new_state) { … }

void MediaStreamDeviceObserverProxy::OnDeviceCaptureConfigurationChange(
    const std::string& in_label, const ::blink::MediaStreamDevice& in_device) { … }

void MediaStreamDeviceObserverProxy::OnDeviceCaptureHandleChange(
    const std::string& in_label, const ::blink::MediaStreamDevice& in_device) { … }

void MediaStreamDeviceObserverProxy::OnZoomLevelChange(
    const std::string& in_label, const ::blink::MediaStreamDevice& in_device, int32_t in_zoom_level) { … }

// static
bool MediaStreamDeviceObserverStubDispatch::Accept(
    MediaStreamDeviceObserver* impl,
    mojo::Message* message) { … }

// static
bool MediaStreamDeviceObserverStubDispatch::AcceptWithResponder(
    MediaStreamDeviceObserver* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // 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 // !BUILDFLAG(IS_FUCHSIA)
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 std::string& in_label, bool in_focus) { … }

void MediaStreamDispatcherHostProxy::CancelRequest(
    int32_t in_request_id) { … }

void MediaStreamDispatcherHostProxy::StopStreamDevice(
    const std::string& in_device_id, const std::optional<::base::UnguessableToken>& in_session_id) { … }

void MediaStreamDispatcherHostProxy::OpenDevice(
    int32_t in_request_id, const std::string& in_device_id, MediaStreamType in_type, OpenDeviceCallback callback) { … }

void MediaStreamDispatcherHostProxy::CloseDevice(
    const std::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::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 std::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 std::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::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) { … }

// static
bool MediaStreamDispatcherHostStubDispatch::Accept(
    MediaStreamDispatcherHost* impl,
    mojo::Message* message) { … }

// static
bool MediaStreamDispatcherHostStubDispatch::AcceptWithResponder(
    MediaStreamDispatcherHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // 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 // !BUILDFLAG(IS_FUCHSIA)

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) { … }

// static
bool MediaStreamTrackMetricsHostStubDispatch::Accept(
    MediaStreamTrackMetricsHost* impl,
    mojo::Message* message) { … }

// static
bool MediaStreamTrackMetricsHostStubDispatch::AcceptWithResponder(
    MediaStreamTrackMetricsHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kMediaStreamTrackMetricsHostValidationInfo[] = …;

bool MediaStreamTrackMetricsHostRequestValidator::Accept(mojo::Message* message) { … }



}  // blink::mojom


namespace mojo {


// static
bool StructTraits<::blink::mojom::SearchOnlyByDeviceId::DataView, ::blink::mojom::SearchOnlyByDeviceIdPtr>::Read(
    ::blink::mojom::SearchOnlyByDeviceId::DataView input,
    ::blink::mojom::SearchOnlyByDeviceIdPtr* output) { … }


// static
bool StructTraits<::blink::mojom::SearchBySessionId::DataView, ::blink::mojom::SearchBySessionIdPtr>::Read(
    ::blink::mojom::SearchBySessionId::DataView input,
    ::blink::mojom::SearchBySessionIdPtr* output) { … }


// static
bool StructTraits<::blink::mojom::MediaStreamDevice::DataView, ::blink::mojom::MediaStreamDevicePtr>::Read(
    ::blink::mojom::MediaStreamDevice::DataView input,
    ::blink::mojom::MediaStreamDevicePtr* output) { … }


// static
bool StructTraits<::blink::mojom::TrackControls::DataView, ::blink::mojom::TrackControlsPtr>::Read(
    ::blink::mojom::TrackControls::DataView input,
    ::blink::mojom::TrackControlsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::StreamControls::DataView, ::blink::mojom::StreamControlsPtr>::Read(
    ::blink::mojom::StreamControls::DataView input,
    ::blink::mojom::StreamControlsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::GetOpenDeviceResponse::DataView, ::blink::mojom::GetOpenDeviceResponsePtr>::Read(
    ::blink::mojom::GetOpenDeviceResponse::DataView input,
    ::blink::mojom::GetOpenDeviceResponsePtr* output) { … }


// static
bool StructTraits<::blink::mojom::CapturedWheelAction::DataView, ::blink::mojom::CapturedWheelActionPtr>::Read(
    ::blink::mojom::CapturedWheelAction::DataView input,
    ::blink::mojom::CapturedWheelActionPtr* output) { … }


// static
bool StructTraits<::blink::mojom::StreamDevices::DataView, ::blink::mojom::StreamDevicesPtr>::Read(
    ::blink::mojom::StreamDevices::DataView input,
    ::blink::mojom::StreamDevicesPtr* output) { … }


// static
bool StructTraits<::blink::mojom::StreamDevicesSet::DataView, ::blink::mojom::StreamDevicesSetPtr>::Read(
    ::blink::mojom::StreamDevicesSet::DataView input,
    ::blink::mojom::StreamDevicesSetPtr* output) { … }

// static
bool UnionTraits<::blink::mojom::StreamSelectionInfo::DataView, ::blink::mojom::StreamSelectionInfoPtr>::Read(
    ::blink::mojom::StreamSelectionInfo::DataView input,
    ::blink::mojom::StreamSelectionInfoPtr* output) { … }

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace blink::mojom {


void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceStopped(const std::string& label, const ::blink::MediaStreamDevice& device) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceChanged(const std::string& label, const ::blink::MediaStreamDevice& old_device, const ::blink::MediaStreamDevice& new_device) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceRequestStateChange(const std::string& label, const ::blink::MediaStreamDevice& device, MediaStreamStateChange new_state) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceCaptureConfigurationChange(const std::string& label, const ::blink::MediaStreamDevice& device) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnDeviceCaptureHandleChange(const std::string& label, const ::blink::MediaStreamDevice& device) { … }
void MediaStreamDeviceObserverInterceptorForTesting::OnZoomLevelChange(const std::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 std::string& label, bool focus) { … }
void MediaStreamDispatcherHostInterceptorForTesting::CancelRequest(int32_t request_id) { … }
void MediaStreamDispatcherHostInterceptorForTesting::StopStreamDevice(const std::string& device_id, const std::optional<::base::UnguessableToken>& session_id) { … }
void MediaStreamDispatcherHostInterceptorForTesting::OpenDevice(int32_t request_id, const std::string& device_id, MediaStreamType type, OpenDeviceCallback callback) { … }
void MediaStreamDispatcherHostInterceptorForTesting::CloseDevice(const std::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::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, std::string* out_label, StreamDevicesSetPtr* out_stream_devices, bool* out_pan_tilt_zoom_allowed) { … }



void MediaStreamDispatcherHostAsyncWaiter::OpenDevice(
    int32_t request_id, const std::string& device_id, MediaStreamType type, bool* out_success, std::string* out_label, ::blink::MediaStreamDevice* out_device) { … }



void MediaStreamDispatcherHostAsyncWaiter::ApplySubCaptureTarget(
    const ::base::UnguessableToken& session_id, ::media::mojom::SubCaptureTargetType type, const ::base::Token& sub_capture_target, uint32_t sub_capture_target_version, ::media::mojom::ApplySubCaptureTargetResult* out_result) { … }

::media::mojom::ApplySubCaptureTargetResult MediaStreamDispatcherHostAsyncWaiter::ApplySubCaptureTarget(
    const ::base::UnguessableToken& session_id, ::media::mojom::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;






}  // blink::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/third_party/blink/public/mojom/mediastream/media_stream.mojom.cc
