chromium/out/Default/gen/components/media_router/common/mojom/media_router.mojom.cc

// components/media_router/common/mojom/media_router.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 "components/media_router/common/mojom/media_router.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 "components/media_router/common/mojom/media_router.mojom-params-data.h"
#include "components/media_router/common/mojom/media_router.mojom-shared-message-ids.h"

#include "components/media_router/common/mojom/media_router.mojom-import-headers.h"
#include "components/media_router/common/mojom/media_router.mojom-test-utils.h"


namespace media_router::mojom {
MediaSink::MediaSink()
    : … { … }

MediaSink::MediaSink(
    const std::string& sink_id_in,
    const std::string& name_in,
    SinkIconType icon_type_in,
    ::media_router::mojom::MediaRouteProviderId provider_id_in,
    MediaSinkExtraDataPtr extra_data_in)
    : … { … }

MediaSink::~MediaSink() = default;

void MediaSink::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool MediaSink::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
DialMediaSink::DialMediaSink()
    : … { … }

DialMediaSink::DialMediaSink(
    const ::net::IPAddress& ip_address_in,
    const std::string& model_name_in,
    const ::GURL& app_url_in)
    : … { … }

DialMediaSink::~DialMediaSink() = default;

void DialMediaSink::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool DialMediaSink::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
CastMediaSink::CastMediaSink()
    : … { … }

CastMediaSink::CastMediaSink(
    const ::net::IPEndPoint& ip_endpoint_in,
    const std::string& model_name_in,
    uint64_t capabilities_in,
    int32_t cast_channel_id_in)
    : … { … }

CastMediaSink::~CastMediaSink() = default;

void CastMediaSink::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool CastMediaSink::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
MediaRoute::MediaRoute()
    : … { … }

MediaRoute::MediaRoute(
    const std::string& media_route_id_in,
    const std::string& presentation_id_in,
    const std::optional<std::string>& media_source_in,
    const std::string& media_sink_id_in,
    const std::string& media_sink_name_in,
    const std::string& description_in,
    bool is_local_in,
    RouteControllerType controller_type_in,
    bool is_local_presentation_in,
    bool is_connecting_in)
    : … { … }

MediaRoute::~MediaRoute() = default;

void MediaRoute::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool MediaRoute::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Issue::Issue()
    : … { … }

Issue::Issue(
    const std::string& route_id_in,
    const std::string& sink_id_in,
    ::media_router::IssueInfo::Severity severity_in,
    const std::string& title_in,
    const std::optional<std::string>& message_in)
    : … { … }

Issue::~Issue() = default;

void Issue::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Issue::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
RouteMessage::RouteMessage()
    : … { … }

RouteMessage::RouteMessage(
    RouteMessage::Type type_in,
    const std::optional<std::string>& message_in,
    std::optional<std::vector<uint8_t>> data_in)
    : … { … }

RouteMessage::~RouteMessage() = default;

void RouteMessage::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool RouteMessage::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
RoutePresentationConnection::RoutePresentationConnection()
    : … { … }

RoutePresentationConnection::RoutePresentationConnection(
    ::mojo::PendingRemote<::blink::mojom::PresentationConnection> connection_remote_in,
    ::mojo::PendingReceiver<::blink::mojom::PresentationConnection> connection_receiver_in)
    : … { … }

RoutePresentationConnection::~RoutePresentationConnection() = default;

void RoutePresentationConnection::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool RoutePresentationConnection::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
CastSessionState::CastSessionState()
    : … { … }

CastSessionState::CastSessionState(
    const std::string& sink_id_in,
    const std::string& app_id_in,
    const std::string& session_id_in,
    const std::string& route_description_in)
    : … { … }

CastSessionState::~CastSessionState() = default;
size_t CastSessionState::Hash(size_t seed) const { … }

void CastSessionState::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool CastSessionState::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
CastProviderState::CastProviderState()
    : … { … }

CastProviderState::CastProviderState(
    std::vector<CastSessionStatePtr> session_state_in)
    : … { … }

CastProviderState::~CastProviderState() = default;

void CastProviderState::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool CastProviderState::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
MediaSinkExtraData::MediaSinkExtraData() : … { … }

MediaSinkExtraData::~MediaSinkExtraData() { … }


void MediaSinkExtraData::set_dial_media_sink(
    DialMediaSinkPtr dial_media_sink) { … }
void MediaSinkExtraData::set_cast_media_sink(
    CastMediaSinkPtr cast_media_sink) { … }

void MediaSinkExtraData::DestroyActive() { … }

bool MediaSinkExtraData::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ProviderState::ProviderState() : … { … }

ProviderState::~ProviderState() { … }


void ProviderState::set_cast_provider_state(
    CastProviderStatePtr cast_provider_state) { … }

void ProviderState::DestroyActive() { … }

bool ProviderState::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char MediaRouteProvider::Name_[] = …;

MediaRouteProvider::IPCStableHashFunction MediaRouteProvider::MessageToMethodInfo_(mojo::Message& message) { … }


const char* MediaRouteProvider::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaRouteProvider::CreateRoute_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::JoinRoute_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::TerminateRoute_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::SendRouteMessage_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::SendRouteBinaryMessage_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::StartObservingMediaSinks_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::StopObservingMediaSinks_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::StartObservingMediaRoutes_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::DetachRoute_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::EnableMdnsDiscovery_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::DiscoverSinksNow_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::BindMediaController_Sym::IPCStableHash() { … }
uint32_t MediaRouteProvider::GetState_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class MediaRouteProvider_CreateRoute_ForwardToCallback
    : public mojo::MessageReceiver { … };

class MediaRouteProvider_JoinRoute_ForwardToCallback
    : public mojo::MessageReceiver { … };

class MediaRouteProvider_TerminateRoute_ForwardToCallback
    : public mojo::MessageReceiver { … };

class MediaRouteProvider_BindMediaController_ForwardToCallback
    : public mojo::MessageReceiver { … };

class MediaRouteProvider_GetState_ForwardToCallback
    : public mojo::MessageReceiver { … };

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

void MediaRouteProviderProxy::CreateRoute(
    const std::string& in_media_source, const std::string& in_sink_id, const std::string& in_original_presentation_id, const ::url::Origin& in_origin, int32_t in_frame_tree_node_id, ::base::TimeDelta in_timeout, CreateRouteCallback callback) { … }

void MediaRouteProviderProxy::JoinRoute(
    const std::string& in_media_source, const std::string& in_presentation_id, const ::url::Origin& in_origin, int32_t in_frame_tree_node_id, ::base::TimeDelta in_timeout, JoinRouteCallback callback) { … }

void MediaRouteProviderProxy::TerminateRoute(
    const std::string& in_route_id, TerminateRouteCallback callback) { … }

void MediaRouteProviderProxy::SendRouteMessage(
    const std::string& in_media_route_id, const std::string& in_message) { … }

void MediaRouteProviderProxy::SendRouteBinaryMessage(
    const std::string& in_media_route_id, const std::vector<uint8_t>& in_data) { … }

void MediaRouteProviderProxy::StartObservingMediaSinks(
    const std::string& in_media_source) { … }

void MediaRouteProviderProxy::StopObservingMediaSinks(
    const std::string& in_media_source) { … }

void MediaRouteProviderProxy::StartObservingMediaRoutes(
    ) { … }

void MediaRouteProviderProxy::DetachRoute(
    const std::string& in_route_id) { … }

void MediaRouteProviderProxy::EnableMdnsDiscovery(
    ) { … }

void MediaRouteProviderProxy::DiscoverSinksNow(
    ) { … }

void MediaRouteProviderProxy::BindMediaController(
    const std::string& in_route_id, ::mojo::PendingReceiver<::media_router::mojom::MediaController> in_media_controller, ::mojo::PendingRemote<::media_router::mojom::MediaStatusObserver> in_observer, BindMediaControllerCallback callback) { … }

void MediaRouteProviderProxy::GetState(
    GetStateCallback callback) { … }
class MediaRouteProvider_CreateRoute_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void MediaRouteProvider_CreateRoute_ProxyToResponder::Run(
    const std::optional<::media_router::MediaRoute>& in_route, RoutePresentationConnectionPtr in_connection, const std::optional<std::string>& in_error_text, ::media_router::mojom::RouteRequestResultCode in_result_code) { … }
class MediaRouteProvider_JoinRoute_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void MediaRouteProvider_JoinRoute_ProxyToResponder::Run(
    const std::optional<::media_router::MediaRoute>& in_route, RoutePresentationConnectionPtr in_connection, const std::optional<std::string>& in_error_text, ::media_router::mojom::RouteRequestResultCode in_result_code) { … }
class MediaRouteProvider_TerminateRoute_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void MediaRouteProvider_TerminateRoute_ProxyToResponder::Run(
    const std::optional<std::string>& in_error_text, ::media_router::mojom::RouteRequestResultCode in_result_code) { … }
class MediaRouteProvider_BindMediaController_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void MediaRouteProvider_BindMediaController_ProxyToResponder::Run(
    bool in_success) { … }
class MediaRouteProvider_GetState_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void MediaRouteProvider_GetState_ProxyToResponder::Run(
    ProviderStatePtr in_state) { … }

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

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

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

bool MediaRouteProviderResponseValidator::Accept(mojo::Message* message) { … }
const char MediaRouter::Name_[] = …;

MediaRouter::IPCStableHashFunction MediaRouter::MessageToMethodInfo_(mojo::Message& message) { … }


const char* MediaRouter::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t MediaRouter::RegisterMediaRouteProvider_Sym::IPCStableHash() { … }
uint32_t MediaRouter::OnSinksReceived_Sym::IPCStableHash() { … }
uint32_t MediaRouter::OnIssue_Sym::IPCStableHash() { … }
uint32_t MediaRouter::ClearTopIssueForSink_Sym::IPCStableHash() { … }
uint32_t MediaRouter::OnRoutesUpdated_Sym::IPCStableHash() { … }
uint32_t MediaRouter::OnPresentationConnectionStateChanged_Sym::IPCStableHash() { … }
uint32_t MediaRouter::OnPresentationConnectionClosed_Sym::IPCStableHash() { … }
uint32_t MediaRouter::OnRouteMessagesReceived_Sym::IPCStableHash() { … }
uint32_t MediaRouter::GetMediaSinkServiceStatus_Sym::IPCStableHash() { … }
uint32_t MediaRouter::GetLogger_Sym::IPCStableHash() { … }
uint32_t MediaRouter::GetDebugger_Sym::IPCStableHash() { … }
uint32_t MediaRouter::GetLogsAsString_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class MediaRouter_GetMediaSinkServiceStatus_ForwardToCallback
    : public mojo::MessageReceiver { … };

class MediaRouter_GetLogsAsString_ForwardToCallback
    : public mojo::MessageReceiver { … };

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

void MediaRouterProxy::RegisterMediaRouteProvider(
    ::media_router::mojom::MediaRouteProviderId in_provider_id, ::mojo::PendingRemote<MediaRouteProvider> in_media_router_provider) { … }

void MediaRouterProxy::OnSinksReceived(
    ::media_router::mojom::MediaRouteProviderId in_provider_id, const std::string& in_media_source, const std::vector<::media_router::MediaSinkInternal>& in_sinks, const std::vector<::url::Origin>& in_origins) { … }

void MediaRouterProxy::OnIssue(
    const ::media_router::IssueInfo& in_issue) { … }

void MediaRouterProxy::ClearTopIssueForSink(
    const std::string& in_sink_id) { … }

void MediaRouterProxy::OnRoutesUpdated(
    ::media_router::mojom::MediaRouteProviderId in_provider_id, const std::vector<::media_router::MediaRoute>& in_routes) { … }

void MediaRouterProxy::OnPresentationConnectionStateChanged(
    const std::string& in_route_id, ::blink::mojom::PresentationConnectionState in_state) { … }

void MediaRouterProxy::OnPresentationConnectionClosed(
    const std::string& in_route_id, ::blink::mojom::PresentationConnectionCloseReason in_reason, const std::string& in_message) { … }

void MediaRouterProxy::OnRouteMessagesReceived(
    const std::string& in_route_id, std::vector<RouteMessagePtr> in_messages) { … }

void MediaRouterProxy::GetMediaSinkServiceStatus(
    GetMediaSinkServiceStatusCallback callback) { … }

void MediaRouterProxy::GetLogger(
    ::mojo::PendingReceiver<::media_router::mojom::Logger> in_receiver) { … }

void MediaRouterProxy::GetDebugger(
    ::mojo::PendingReceiver<::media_router::mojom::Debugger> in_receiver) { … }

void MediaRouterProxy::GetLogsAsString(
    GetLogsAsStringCallback callback) { … }
class MediaRouter_GetMediaSinkServiceStatus_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void MediaRouter_GetMediaSinkServiceStatus_ProxyToResponder::Run(
    const std::string& in_status) { … }
class MediaRouter_GetLogsAsString_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void MediaRouter_GetLogsAsString_ProxyToResponder::Run(
    const std::string& in_logs) { … }

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

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

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

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


}  // media_router::mojom


namespace mojo {


// static
bool StructTraits<::media_router::mojom::MediaSink::DataView, ::media_router::mojom::MediaSinkPtr>::Read(
    ::media_router::mojom::MediaSink::DataView input,
    ::media_router::mojom::MediaSinkPtr* output) { … }


// static
bool StructTraits<::media_router::mojom::DialMediaSink::DataView, ::media_router::mojom::DialMediaSinkPtr>::Read(
    ::media_router::mojom::DialMediaSink::DataView input,
    ::media_router::mojom::DialMediaSinkPtr* output) { … }


// static
bool StructTraits<::media_router::mojom::CastMediaSink::DataView, ::media_router::mojom::CastMediaSinkPtr>::Read(
    ::media_router::mojom::CastMediaSink::DataView input,
    ::media_router::mojom::CastMediaSinkPtr* output) { … }


// static
bool StructTraits<::media_router::mojom::MediaRoute::DataView, ::media_router::mojom::MediaRoutePtr>::Read(
    ::media_router::mojom::MediaRoute::DataView input,
    ::media_router::mojom::MediaRoutePtr* output) { … }


// static
bool StructTraits<::media_router::mojom::Issue::DataView, ::media_router::mojom::IssuePtr>::Read(
    ::media_router::mojom::Issue::DataView input,
    ::media_router::mojom::IssuePtr* output) { … }


// static
bool StructTraits<::media_router::mojom::RouteMessage::DataView, ::media_router::mojom::RouteMessagePtr>::Read(
    ::media_router::mojom::RouteMessage::DataView input,
    ::media_router::mojom::RouteMessagePtr* output) { … }


// static
bool StructTraits<::media_router::mojom::RoutePresentationConnection::DataView, ::media_router::mojom::RoutePresentationConnectionPtr>::Read(
    ::media_router::mojom::RoutePresentationConnection::DataView input,
    ::media_router::mojom::RoutePresentationConnectionPtr* output) { … }


// static
bool StructTraits<::media_router::mojom::CastSessionState::DataView, ::media_router::mojom::CastSessionStatePtr>::Read(
    ::media_router::mojom::CastSessionState::DataView input,
    ::media_router::mojom::CastSessionStatePtr* output) { … }


// static
bool StructTraits<::media_router::mojom::CastProviderState::DataView, ::media_router::mojom::CastProviderStatePtr>::Read(
    ::media_router::mojom::CastProviderState::DataView input,
    ::media_router::mojom::CastProviderStatePtr* output) { … }

// static
bool UnionTraits<::media_router::mojom::MediaSinkExtraData::DataView, ::media_router::mojom::MediaSinkExtraDataPtr>::Read(
    ::media_router::mojom::MediaSinkExtraData::DataView input,
    ::media_router::mojom::MediaSinkExtraDataPtr* output) { … }

// static
bool UnionTraits<::media_router::mojom::ProviderState::DataView, ::media_router::mojom::ProviderStatePtr>::Read(
    ::media_router::mojom::ProviderState::DataView input,
    ::media_router::mojom::ProviderStatePtr* 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 media_router::mojom {


void MediaRouteProviderInterceptorForTesting::CreateRoute(const std::string& media_source, const std::string& sink_id, const std::string& original_presentation_id, const ::url::Origin& origin, int32_t frame_tree_node_id, ::base::TimeDelta timeout, CreateRouteCallback callback) { … }
void MediaRouteProviderInterceptorForTesting::JoinRoute(const std::string& media_source, const std::string& presentation_id, const ::url::Origin& origin, int32_t frame_tree_node_id, ::base::TimeDelta timeout, JoinRouteCallback callback) { … }
void MediaRouteProviderInterceptorForTesting::TerminateRoute(const std::string& route_id, TerminateRouteCallback callback) { … }
void MediaRouteProviderInterceptorForTesting::SendRouteMessage(const std::string& media_route_id, const std::string& message) { … }
void MediaRouteProviderInterceptorForTesting::SendRouteBinaryMessage(const std::string& media_route_id, const std::vector<uint8_t>& data) { … }
void MediaRouteProviderInterceptorForTesting::StartObservingMediaSinks(const std::string& media_source) { … }
void MediaRouteProviderInterceptorForTesting::StopObservingMediaSinks(const std::string& media_source) { … }
void MediaRouteProviderInterceptorForTesting::StartObservingMediaRoutes() { … }
void MediaRouteProviderInterceptorForTesting::DetachRoute(const std::string& route_id) { … }
void MediaRouteProviderInterceptorForTesting::EnableMdnsDiscovery() { … }
void MediaRouteProviderInterceptorForTesting::DiscoverSinksNow() { … }
void MediaRouteProviderInterceptorForTesting::BindMediaController(const std::string& route_id, ::mojo::PendingReceiver<::media_router::mojom::MediaController> media_controller, ::mojo::PendingRemote<::media_router::mojom::MediaStatusObserver> observer, BindMediaControllerCallback callback) { … }
void MediaRouteProviderInterceptorForTesting::GetState(GetStateCallback callback) { … }
MediaRouteProviderAsyncWaiter::MediaRouteProviderAsyncWaiter(
    MediaRouteProvider* proxy) : … { … }

MediaRouteProviderAsyncWaiter::~MediaRouteProviderAsyncWaiter() = default;

void MediaRouteProviderAsyncWaiter::CreateRoute(
    const std::string& media_source, const std::string& sink_id, const std::string& original_presentation_id, const ::url::Origin& origin, int32_t frame_tree_node_id, ::base::TimeDelta timeout, std::optional<::media_router::MediaRoute>* out_route, RoutePresentationConnectionPtr* out_connection, std::optional<std::string>* out_error_text, ::media_router::mojom::RouteRequestResultCode* out_result_code) { … }



void MediaRouteProviderAsyncWaiter::JoinRoute(
    const std::string& media_source, const std::string& presentation_id, const ::url::Origin& origin, int32_t frame_tree_node_id, ::base::TimeDelta timeout, std::optional<::media_router::MediaRoute>* out_route, RoutePresentationConnectionPtr* out_connection, std::optional<std::string>* out_error_text, ::media_router::mojom::RouteRequestResultCode* out_result_code) { … }



void MediaRouteProviderAsyncWaiter::TerminateRoute(
    const std::string& route_id, std::optional<std::string>* out_error_text, ::media_router::mojom::RouteRequestResultCode* out_result_code) { … }



void MediaRouteProviderAsyncWaiter::BindMediaController(
    const std::string& route_id, ::mojo::PendingReceiver<::media_router::mojom::MediaController> media_controller, ::mojo::PendingRemote<::media_router::mojom::MediaStatusObserver> observer, bool* out_success) { … }

bool MediaRouteProviderAsyncWaiter::BindMediaController(
    const std::string& route_id, ::mojo::PendingReceiver<::media_router::mojom::MediaController> media_controller, ::mojo::PendingRemote<::media_router::mojom::MediaStatusObserver> observer) { … }

void MediaRouteProviderAsyncWaiter::GetState(
    ProviderStatePtr* out_state) { … }

ProviderStatePtr MediaRouteProviderAsyncWaiter::GetState(
    ) { … }




void MediaRouterInterceptorForTesting::RegisterMediaRouteProvider(::media_router::mojom::MediaRouteProviderId provider_id, ::mojo::PendingRemote<MediaRouteProvider> media_router_provider) { … }
void MediaRouterInterceptorForTesting::OnSinksReceived(::media_router::mojom::MediaRouteProviderId provider_id, const std::string& media_source, const std::vector<::media_router::MediaSinkInternal>& sinks, const std::vector<::url::Origin>& origins) { … }
void MediaRouterInterceptorForTesting::OnIssue(const ::media_router::IssueInfo& issue) { … }
void MediaRouterInterceptorForTesting::ClearTopIssueForSink(const std::string& sink_id) { … }
void MediaRouterInterceptorForTesting::OnRoutesUpdated(::media_router::mojom::MediaRouteProviderId provider_id, const std::vector<::media_router::MediaRoute>& routes) { … }
void MediaRouterInterceptorForTesting::OnPresentationConnectionStateChanged(const std::string& route_id, ::blink::mojom::PresentationConnectionState state) { … }
void MediaRouterInterceptorForTesting::OnPresentationConnectionClosed(const std::string& route_id, ::blink::mojom::PresentationConnectionCloseReason reason, const std::string& message) { … }
void MediaRouterInterceptorForTesting::OnRouteMessagesReceived(const std::string& route_id, std::vector<RouteMessagePtr> messages) { … }
void MediaRouterInterceptorForTesting::GetMediaSinkServiceStatus(GetMediaSinkServiceStatusCallback callback) { … }
void MediaRouterInterceptorForTesting::GetLogger(::mojo::PendingReceiver<::media_router::mojom::Logger> receiver) { … }
void MediaRouterInterceptorForTesting::GetDebugger(::mojo::PendingReceiver<::media_router::mojom::Debugger> receiver) { … }
void MediaRouterInterceptorForTesting::GetLogsAsString(GetLogsAsStringCallback callback) { … }
MediaRouterAsyncWaiter::MediaRouterAsyncWaiter(
    MediaRouter* proxy) : … { … }

MediaRouterAsyncWaiter::~MediaRouterAsyncWaiter() = default;

void MediaRouterAsyncWaiter::GetMediaSinkServiceStatus(
    std::string* out_status) { … }

std::string MediaRouterAsyncWaiter::GetMediaSinkServiceStatus(
    ) { … }

void MediaRouterAsyncWaiter::GetLogsAsString(
    std::string* out_logs) { … }

std::string MediaRouterAsyncWaiter::GetLogsAsString(
    ) { … }






}  // media_router::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif