isolated_xr_service.mojom.cc | Explore in Territory

// device/vr/public/mojom/isolated_xr_service.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 "device/vr/public/mojom/isolated_xr_service.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 "device/vr/public/mojom/isolated_xr_service.mojom-params-data.h"
#include "device/vr/public/mojom/isolated_xr_service.mojom-shared-message-ids.h"

#include "device/vr/public/mojom/isolated_xr_service.mojom-import-headers.h"
#include "device/vr/public/mojom/isolated_xr_service.mojom-test-utils.h"


namespace device::mojom {
XRRuntimeSessionOptions::XRRuntimeSessionOptions()
    : … { … }

XRRuntimeSessionOptions::XRRuntimeSessionOptions(
    ::device::mojom::XRSessionMode mode_in,
    std::vector<::device::mojom::XRSessionFeature> required_features_in,
    std::vector<::device::mojom::XRSessionFeature> optional_features_in,
    int32_t render_process_id_in,
    int32_t render_frame_id_in,
    std::vector<::device::mojom::XRTrackedImagePtr> tracked_images_in,
    ::device::mojom::XRDepthOptionsPtr depth_options_in,
    uint64_t trace_id_in)
    : … { … }

XRRuntimeSessionOptions::~XRRuntimeSessionOptions() = default;

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

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

XRRuntimeSessionResult::XRRuntimeSessionResult(
    ::mojo::PendingRemote<XRSessionController> controller_in,
    ::device::mojom::XRSessionPtr session_in,
    const std::optional<::viz::FrameSinkId>& frame_sink_id_in,
    ::mojo::PendingRemote<ImmersiveOverlay> overlay_in)
    : … { … }

XRRuntimeSessionResult::~XRRuntimeSessionResult() = default;

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

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

XRRenderInfo::XRRenderInfo(
    int16_t frame_id_in,
    ::device::mojom::VRPosePtr mojo_from_viewer_in,
    std::vector<::device::mojom::XRViewPtr> views_in)
    : … { … }

XRRenderInfo::~XRRenderInfo() = default;

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

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

XRDeviceData::XRDeviceData(
    std::vector<::device::mojom::XRSessionFeature> supported_features_in,
    bool is_ar_blend_mode_supported_in)
    : … { … }

XRDeviceData::~XRDeviceData() = default;

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRSessionController::SetFrameDataRestricted_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void XRSessionControllerProxy::SetFrameDataRestricted(
    bool in_restricted) { … }

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

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

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

const char XRRuntimeEventListener::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRRuntimeEventListener::OnVisibilityStateChanged_Sym::IPCStableHash() { … }
uint32_t XRRuntimeEventListener::OnExitPresent_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void XRRuntimeEventListenerProxy::OnVisibilityStateChanged(
    ::device::mojom::XRVisibilityState in_visibility_state) { … }

void XRRuntimeEventListenerProxy::OnExitPresent(
    ) { … }

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

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

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

const char XRRuntime::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRRuntime::RequestSession_Sym::IPCStableHash() { … }
uint32_t XRRuntime::ShutdownSession_Sym::IPCStableHash() { … }
uint32_t XRRuntime::ListenToDeviceChanges_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

void XRRuntimeProxy::RequestSession(
    XRRuntimeSessionOptionsPtr in_options, RequestSessionCallback callback) { … }

void XRRuntimeProxy::ShutdownSession(
    ShutdownSessionCallback callback) { … }

void XRRuntimeProxy::ListenToDeviceChanges(
    ::mojo::PendingAssociatedRemote<XRRuntimeEventListener> in_listener) { … }
class XRRuntime_RequestSession_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void XRRuntime_RequestSession_ProxyToResponder::Run(
    XRRuntimeSessionResultPtr in_session) { … }
class XRRuntime_ShutdownSession_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void XRRuntime_ShutdownSession_ProxyToResponder::Run(
    ) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t ImmersiveOverlay::RequestNextOverlayPose_Sym::IPCStableHash() { … }
uint32_t ImmersiveOverlay::SubmitOverlayTexture_Sym::IPCStableHash() { … }
uint32_t ImmersiveOverlay::SetOverlayAndWebXRVisibility_Sym::IPCStableHash() { … }
uint32_t ImmersiveOverlay::RequestNotificationOnWebXrSubmitted_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

void ImmersiveOverlayProxy::RequestNextOverlayPose(
    RequestNextOverlayPoseCallback callback) { … }

void ImmersiveOverlayProxy::SubmitOverlayTexture(
    int16_t in_frame_id, ::gfx::GpuMemoryBufferHandle in_texture, const ::gpu::SyncToken& in_sync_token, const ::gfx::RectF& in_left_bounds, const ::gfx::RectF& in_right_bounds, SubmitOverlayTextureCallback callback) { … }

void ImmersiveOverlayProxy::SetOverlayAndWebXRVisibility(
    bool in_overlay_visible, bool in_webxr_visible) { … }

void ImmersiveOverlayProxy::RequestNotificationOnWebXrSubmitted(
    RequestNotificationOnWebXrSubmittedCallback callback) { … }
class ImmersiveOverlay_RequestNextOverlayPose_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void ImmersiveOverlay_RequestNextOverlayPose_ProxyToResponder::Run(
    XRRenderInfoPtr in_render_info) { … }
class ImmersiveOverlay_SubmitOverlayTexture_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

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

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

void ImmersiveOverlay_RequestNotificationOnWebXrSubmitted_ProxyToResponder::Run(
    ) { … }

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

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

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

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IsolatedXRRuntimeProviderClient::OnDeviceAdded_Sym::IPCStableHash() { … }
uint32_t IsolatedXRRuntimeProviderClient::OnDeviceRemoved_Sym::IPCStableHash() { … }
uint32_t IsolatedXRRuntimeProviderClient::OnDevicesEnumerated_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void IsolatedXRRuntimeProviderClientProxy::OnDeviceAdded(
    ::mojo::PendingRemote<XRRuntime> in_runtime, XRDeviceDataPtr in_device_data, ::device::mojom::XRDeviceId in_device_id) { … }

void IsolatedXRRuntimeProviderClientProxy::OnDeviceRemoved(
    ::device::mojom::XRDeviceId in_device_index) { … }

void IsolatedXRRuntimeProviderClientProxy::OnDevicesEnumerated(
    ) { … }

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

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

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

const char IsolatedXRRuntimeProvider::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t IsolatedXRRuntimeProvider::RequestDevices_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void IsolatedXRRuntimeProviderProxy::RequestDevices(
    ::mojo::PendingRemote<IsolatedXRRuntimeProviderClient> in_client) { … }

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

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

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

const char XRDeviceService::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRDeviceService::BindRuntimeProvider_Sym::IPCStableHash() { … }
uint32_t XRDeviceService::BindTestHook_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void XRDeviceServiceProxy::BindRuntimeProvider(
    ::mojo::PendingReceiver<IsolatedXRRuntimeProvider> in_receiver, ::mojo::PendingRemote<XRDeviceServiceHost> in_host) { … }

void XRDeviceServiceProxy::BindTestHook(
    ::mojo::PendingReceiver<::device_test::mojom::XRServiceTestHook> in_receiver) { … }

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

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

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

const char XRDeviceServiceHost::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRDeviceServiceHost::BindGpu_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void XRDeviceServiceHostProxy::BindGpu(
    ::mojo::PendingReceiver<::viz::mojom::Gpu> in_receiver) { … }

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

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

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



}  // device::mojom


namespace mojo {


// static
bool StructTraits<::device::mojom::XRRuntimeSessionOptions::DataView, ::device::mojom::XRRuntimeSessionOptionsPtr>::Read(
    ::device::mojom::XRRuntimeSessionOptions::DataView input,
    ::device::mojom::XRRuntimeSessionOptionsPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRRuntimeSessionResult::DataView, ::device::mojom::XRRuntimeSessionResultPtr>::Read(
    ::device::mojom::XRRuntimeSessionResult::DataView input,
    ::device::mojom::XRRuntimeSessionResultPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRRenderInfo::DataView, ::device::mojom::XRRenderInfoPtr>::Read(
    ::device::mojom::XRRenderInfo::DataView input,
    ::device::mojom::XRRenderInfoPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRDeviceData::DataView, ::device::mojom::XRDeviceDataPtr>::Read(
    ::device::mojom::XRDeviceData::DataView input,
    ::device::mojom::XRDeviceDataPtr* 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 device::mojom {


void XRSessionControllerInterceptorForTesting::SetFrameDataRestricted(bool restricted) { … }
XRSessionControllerAsyncWaiter::XRSessionControllerAsyncWaiter(
    XRSessionController* proxy) : … { … }

XRSessionControllerAsyncWaiter::~XRSessionControllerAsyncWaiter() = default;




void XRRuntimeEventListenerInterceptorForTesting::OnVisibilityStateChanged(::device::mojom::XRVisibilityState visibility_state) { … }
void XRRuntimeEventListenerInterceptorForTesting::OnExitPresent() { … }
XRRuntimeEventListenerAsyncWaiter::XRRuntimeEventListenerAsyncWaiter(
    XRRuntimeEventListener* proxy) : … { … }

XRRuntimeEventListenerAsyncWaiter::~XRRuntimeEventListenerAsyncWaiter() = default;




void XRRuntimeInterceptorForTesting::RequestSession(XRRuntimeSessionOptionsPtr options, RequestSessionCallback callback) { … }
void XRRuntimeInterceptorForTesting::ShutdownSession(ShutdownSessionCallback callback) { … }
void XRRuntimeInterceptorForTesting::ListenToDeviceChanges(::mojo::PendingAssociatedRemote<XRRuntimeEventListener> listener) { … }
XRRuntimeAsyncWaiter::XRRuntimeAsyncWaiter(
    XRRuntime* proxy) : … { … }

XRRuntimeAsyncWaiter::~XRRuntimeAsyncWaiter() = default;

void XRRuntimeAsyncWaiter::RequestSession(
    XRRuntimeSessionOptionsPtr options, XRRuntimeSessionResultPtr* out_session) { … }

XRRuntimeSessionResultPtr XRRuntimeAsyncWaiter::RequestSession(
    XRRuntimeSessionOptionsPtr options) { … }

void XRRuntimeAsyncWaiter::ShutdownSession(
    ) { … }






void ImmersiveOverlayInterceptorForTesting::RequestNextOverlayPose(RequestNextOverlayPoseCallback callback) { … }
void ImmersiveOverlayInterceptorForTesting::SubmitOverlayTexture(int16_t frame_id, ::gfx::GpuMemoryBufferHandle texture, const ::gpu::SyncToken& sync_token, const ::gfx::RectF& left_bounds, const ::gfx::RectF& right_bounds, SubmitOverlayTextureCallback callback) { … }
void ImmersiveOverlayInterceptorForTesting::SetOverlayAndWebXRVisibility(bool overlay_visible, bool webxr_visible) { … }
void ImmersiveOverlayInterceptorForTesting::RequestNotificationOnWebXrSubmitted(RequestNotificationOnWebXrSubmittedCallback callback) { … }
ImmersiveOverlayAsyncWaiter::ImmersiveOverlayAsyncWaiter(
    ImmersiveOverlay* proxy) : … { … }

ImmersiveOverlayAsyncWaiter::~ImmersiveOverlayAsyncWaiter() = default;

void ImmersiveOverlayAsyncWaiter::RequestNextOverlayPose(
    XRRenderInfoPtr* out_render_info) { … }

XRRenderInfoPtr ImmersiveOverlayAsyncWaiter::RequestNextOverlayPose(
    ) { … }

void ImmersiveOverlayAsyncWaiter::SubmitOverlayTexture(
    int16_t frame_id, ::gfx::GpuMemoryBufferHandle texture, const ::gpu::SyncToken& sync_token, const ::gfx::RectF& left_bounds, const ::gfx::RectF& right_bounds, bool* out_success) { … }

bool ImmersiveOverlayAsyncWaiter::SubmitOverlayTexture(
    int16_t frame_id, ::gfx::GpuMemoryBufferHandle texture, const ::gpu::SyncToken& sync_token, const ::gfx::RectF& left_bounds, const ::gfx::RectF& right_bounds) { … }

void ImmersiveOverlayAsyncWaiter::RequestNotificationOnWebXrSubmitted(
    ) { … }






void IsolatedXRRuntimeProviderClientInterceptorForTesting::OnDeviceAdded(::mojo::PendingRemote<XRRuntime> runtime, XRDeviceDataPtr device_data, ::device::mojom::XRDeviceId device_id) { … }
void IsolatedXRRuntimeProviderClientInterceptorForTesting::OnDeviceRemoved(::device::mojom::XRDeviceId device_index) { … }
void IsolatedXRRuntimeProviderClientInterceptorForTesting::OnDevicesEnumerated() { … }
IsolatedXRRuntimeProviderClientAsyncWaiter::IsolatedXRRuntimeProviderClientAsyncWaiter(
    IsolatedXRRuntimeProviderClient* proxy) : … { … }

IsolatedXRRuntimeProviderClientAsyncWaiter::~IsolatedXRRuntimeProviderClientAsyncWaiter() = default;




void IsolatedXRRuntimeProviderInterceptorForTesting::RequestDevices(::mojo::PendingRemote<IsolatedXRRuntimeProviderClient> client) { … }
IsolatedXRRuntimeProviderAsyncWaiter::IsolatedXRRuntimeProviderAsyncWaiter(
    IsolatedXRRuntimeProvider* proxy) : … { … }

IsolatedXRRuntimeProviderAsyncWaiter::~IsolatedXRRuntimeProviderAsyncWaiter() = default;




void XRDeviceServiceInterceptorForTesting::BindRuntimeProvider(::mojo::PendingReceiver<IsolatedXRRuntimeProvider> receiver, ::mojo::PendingRemote<XRDeviceServiceHost> host) { … }
void XRDeviceServiceInterceptorForTesting::BindTestHook(::mojo::PendingReceiver<::device_test::mojom::XRServiceTestHook> receiver) { … }
XRDeviceServiceAsyncWaiter::XRDeviceServiceAsyncWaiter(
    XRDeviceService* proxy) : … { … }

XRDeviceServiceAsyncWaiter::~XRDeviceServiceAsyncWaiter() = default;




void XRDeviceServiceHostInterceptorForTesting::BindGpu(::mojo::PendingReceiver<::viz::mojom::Gpu> receiver) { … }
XRDeviceServiceHostAsyncWaiter::XRDeviceServiceHostAsyncWaiter(
    XRDeviceServiceHost* proxy) : … { … }

XRDeviceServiceHostAsyncWaiter::~XRDeviceServiceHostAsyncWaiter() = default;






}  // device::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/device/vr/public/mojom/isolated_xr_service.mojom.cc
